Racket เป็นภาษาการเขียนโปรแกรมทั่วไปที่เป็นลูกหลานของ Scheme ซึ่งเป็นผลลัพธ์จาก Lisp โดยถูกออกแบบมาในตอนแรกเป็นแพลตฟอร์มสำหรับการสร้างภาษา Racket มีเครื่องมือที่หลากหลายสำหรับนักพัฒนาในการกำหนดภาษาการเขียนโปรแกรมใหม่และสร้างต้นแบบแนวคิดใหม่อย่างรวดเร็ว มันเน้นแนวทางการเขียนโปรแกรมเชิงฟังก์ชัน และระบบแมโครที่ทรงพลังช่วยให้มีความยืดหยุ่นอย่างมากในการพัฒนาภาษาที่เฉพาะเจาะจง Racket เหมาะสำหรับการศึกษา การวิจัย และการใช้งานใด ๆ ที่ต้องการฟีเจอร์หรือพฤติกรรมของภาษาที่กำหนดเอง
Racket (เดิมเรียกว่า PLT Scheme) ถูกสร้างขึ้นโดยกลุ่มนักวิจัยที่มหาวิทยาลัยนอร์ทอีสเทิร์นในช่วงกลางทศวรรษ 1990 โดยมี Matthew Flatt เป็นผู้นำ มันถูกออกแบบมาเป็นเครื่องมือการศึกษาเพื่อช่วยให้นักเรียนเรียนรู้แนวคิดการเขียนโปรแกรมและการออกแบบภาษา ผ่านทางภาษาย่อย Scheme ของ Lisp เวอร์ชันแรก ๆ ของ Racket มุ่งเน้นไปที่การจัดเตรียมสภาพแวดล้อมที่แข็งแกร่งสำหรับการสอนและการเรียนรู้ภาษาการเขียนโปรแกรม
ในปีถัดมา Racket ได้พัฒนาขึ้นจากรากฐานทางการศึกษา กลายเป็นภาษาการเขียนโปรแกรมทั่วไปที่มีเอกลักษณ์เฉพาะตัว ทีม PLT ได้เปลี่ยนชื่อเป็น Racket ในปี 2010 โดยเน้นความหลากหลายของภาษาและความสามารถในการสนับสนุนแนวทางที่แตกต่างกัน รวมถึงการเขียนโปรแกรมเชิงฟังก์ชัน การเขียนโปรแกรมเชิงคำสั่ง และการเขียนโปรแกรมเชิงวัตถุ ชุมชน Racket เติบโตขึ้น โดยมีการมีส่วนร่วมจากนักการศึกษา นักวิจัย และนักพัฒนาซอฟต์แวร์ ซึ่งเสริมสร้างความสามารถในการออกแบบและการดำเนินการภาษา
ในปัจจุบัน Racket มีชุดไลบรารีและเครื่องมือที่หลากหลาย รวมถึงสภาพแวดล้อมการพัฒนาที่รวมอยู่ (IDE) ที่ทรงพลังชื่อ DrRacket การออกแบบของมันสนับสนุนการสร้างภาษาที่ใหม่ ดังนั้นฐานผู้ใช้ของมันจึงขยายออกไปนอกกรณีการใช้งานการเขียนโปรแกรมแบบดั้งเดิมไปสู่การทดลองและการพัฒนาภาษา Racket มีอิทธิพลในชุมชนภาษาการเขียนโปรแกรมที่กว้างขึ้น ส่งผลกระทบต่อภาษาต่าง ๆ เช่น Julia และมีอิทธิพลต่อการพัฒนาในสภาพแวดล้อมการเขียนโปรแกรมเพื่อการศึกษา
Racket รองรับฟังก์ชันระดับหนึ่ง ซึ่งอนุญาตให้ฟังก์ชันถูกปฏิบัติเสมือนเป็นพลเมืองระดับหนึ่ง นั่นหมายความว่าฟังก์ชันสามารถถูกส่งเป็นอาร์กิวเมนต์ คืนค่าจากฟังก์ชันอื่น ๆ และถูกกำหนดให้กับตัวแปร
(define (apply-twice f x)
(f (f x)))
(apply-twice add1 5) ; คืนค่า 7
ระบบแมโครที่ทรงพลังของ Racket อนุญาตให้มีการขยายไวยากรณ์ ช่วยให้นักพัฒนาสามารถสร้างรูปแบบพิเศษที่ไม่มีอยู่ในภาษาหลัก
(define-syntax-rule (when condition body)
(if condition
(begin body)))
(when (> 3 2)
(display "3 มากกว่า 2")) ; แสดงผล: 3 มากกว่า 2
Racket รองรับการจับคู่รูปแบบผ่าน match ซึ่งช่วยให้เขียนโค้ดที่สะอาดและอ่านง่ายเมื่อทำการแยกข้อมูล
(define (describe lst)
(match lst
[(list 0) "ศูนย์"]
[(list n) (string-append "หนึ่ง: " (number->string n))]
[_ "อื่น ๆ"]))
Racket อนุญาตให้ฟังก์ชันรับอาร์กิวเมนต์จำนวนมากโดยใช้ไวยากรณ์ Ellipsis
(define (sum . numbers)
(apply + numbers))
(sum 1 2 3 4) ; คืนค่า 10
ฟังก์ชันใน Racket สามารถมีอาร์กิวเมนต์ที่เลือกได้และอาร์กิวเมนต์ตามชื่อ ซึ่งให้ความยืดหยุ่นในการกำหนดลายเซ็นของฟังก์ชัน
(define (greet #:name [name "โลก"])
(string-append "สวัสดี, " name "!"))
(greet) ; คืนค่า "สวัสดี, โลก!"
(greet #:name "อลิซ") ; คืนค่า "สวัสดี, อลิซ!"
Racket รองรับการเขียนโปรแกรมเชิงวัตถุผ่านระบบ class ของมัน ซึ่งช่วยให้สามารถสร้างคลาสและเมธอดได้
(define my-class
(class object%
(super-new)
(define/public (greet) "สวัสดี!")))
(define obj (new my-class))
(send obj greet) ; คืนค่า "สวัสดี!"
Racket มีการต่อเนื่องระดับหนึ่ง ซึ่งช่วยให้นักพัฒนาสามารถจัดการการไหลของการควบคุมในวิธีที่ซับซ้อน
(define (call-with-current-continuation f)
(call/cc f))
(call-with-current-continuation
(lambda (k) (k 10))) ; คืนค่า 10
Racket มีการสนับสนุนสัญญาในตัว ซึ่งช่วยให้นักพัฒนากำหนดพฤติกรรมที่คาดหวังของฟังก์ชันและโครงสร้าง
(define/contract (safe-div x y)
(-> number? (and/c number? (not/c (= y 0))) number?)
(/ x y))
Racket ใช้ระบบโมดูลเพื่อช่วยในการจัดระเบียบโค้ดและการนำกลับมาใช้ใหม่
(module my-module racket
(define (hello) "สวัสดีจาก my-module!"))
Typed Racket เป็นรูปแบบหนึ่งของ Racket ที่เพิ่มประเภทแบบสถิต ช่วยให้สามารถตรวจสอบประเภทในระหว่างการพัฒนา
#lang typed/racket
(: add (-> Integer Integer Integer))
(define (add a b) (+ a b))
(add 2 3) ; คืนค่า 5
DrRacket ทำหน้าที่เป็น IDE หลักสำหรับ Racket โดยให้สภาพแวดล้อมที่รวมสำหรับการเขียนและรันโปรแกรม Racket มันมีฟีเจอร์ต่าง ๆ เช่น การเน้นไวยากรณ์ เครื่องมือการดีบัก และ REPL (Read-Eval-Print Loop) สำหรับการเขียนโปรแกรมเชิงโต้ตอบ
Racket มีคอมไพเลอร์ในตัวที่คอมไพล์โค้ด Racket เป็นไบต์โค้ดหรือโค้ดเครื่องพื้นเมืองเพื่อการดำเนินการที่มีประสิทธิภาพ ระบบรันไทม์ของมันจัดการหน่วยความจำ การเก็บขยะ และงานระบบระดับต่ำอื่น ๆ
การสร้างโปรเจกต์ Racket มักเกี่ยวข้องกับการจัดระเบียบโค้ดเป็นโมดูลและใช้ระบบแพ็คเกจ Racket สำหรับการจัดการไลบรารีภายนอก โปรเจกต์สามารถสร้างได้โดยใช้ raco เครื่องมือบรรทัดคำสั่งของ Racket เพื่อคอมไพล์และรันไฟล์ Racket
raco make my-project.rkt
raco run my-project.rkt
Racket ถูกใช้ในหลายโดเมน รวมถึง:
Racket มีความคล้ายคลึงกับภาษาการเขียนโปรแกรมหลายภาษา โดยเน้นรากฐานการเขียนโปรแกรมเชิงฟังก์ชัน:
มีเครื่องมือเช่น racket2cpp ของ Racket ที่อนุญาตให้แปลจาก Racket เป็น C++ หรือภาษาที่คล้ายกัน นอกจากนี้ โครงการวิจัยบางโครงการได้มุ่งเน้นไปที่การแปล Racket เป็น JavaScript หรือ Python เพื่อให้การรวมเข้ากับแอปพลิเคชันเว็บหรือระบบที่มีอยู่ทำได้ง่ายขึ้น
เครื่องมือการแปลจากแหล่งที่มาไปยังแหล่งที่มีอยู่ ได้แก่:
ความยืดหยุ่นและความสามารถในการเขียนโปรแกรมเมตาที่แข็งแกร่งของ Racket ทำให้มันเป็นผู้สมัครที่ยอดเยี่ยมสำหรับการสร้างภาษาและสำรวจแนวทางการเขียนโปรแกรมใหม่ ประวัติศาสตร์ที่หลากหลายและการพัฒนาที่ขับเคลื่อนโดยชุมชนทำให้มันยังคงเป็นเครื่องมือที่มีคุณค่าสำหรับนักการศึกษา นักวิจัย และนักพัฒนาซอฟต์แวร์เช่นกัน