Racket är ett allmänt programmeringsspråk som är en ättling till Scheme, som i sin tur är en avledning av Lisp. Ursprungligen designat som en plattform för språk skapande, erbjuder Racket en rik uppsättning verktyg för utvecklare att definiera nya programmeringsspråk och snabbt prototypa nya idéer. Det betonar funktionella programmeringsparadigm, och dess kraftfulla makrosystem möjliggör betydande flexibilitet i utvecklingen av domänspecifika språk. Racket är särskilt väl lämpat för utbildningsändamål, forskning och alla applikationer som kräver anpassade språkfunktioner eller beteenden.
Racket (ursprungligen kallat PLT Scheme) skapades av en grupp forskare vid Northeastern University i mitten av 1990-talet, ledd av Matthew Flatt. Det designades som ett utbildningsverktyg för att hjälpa studenter att lära sig programmering och språkdesignkoncept genom Scheme-dialekten av Lisp. De tidiga versionerna av Racket fokuserade främst på att tillhandahålla en robust miljö för undervisning och lärande av programmeringsspråk.
Under de följande åren utvecklades Racket bortom sina utbildningsrötter och blev ett allmänt programmeringsspråk med en distinkt identitet. PLT-teamet bytte namn till Racket 2010, vilket betonade språkets mångsidighet och dess kapacitet att stödja olika paradigm, inklusive funktionell, imperativ och objektorienterad programmering. Racket-gemenskapen växte, med bidrag från utbildare, forskare och mjukvaruutvecklare, vilket förstärkte dess kapabiliteter inom språkdesign och exekvering.
Idag har Racket en rik uppsättning bibliotek och verktyg, inklusive en kraftfull integrerad utvecklingsmiljö (IDE) kallad DrRacket. Dess design uppmuntrar skapandet av nya språk; därför sträcker sig dess användarbas bortom traditionella programmeringsanvändningsfall till språkexperimentering och utveckling. Racket har varit inflytelserik inom den bredare programmeringsspråksgemenskapen, och påverkat språk som Julia och påverkat utvecklingen av utbildningsprogrammeringsmiljöer.
Racket stöder förstklassiga funktioner, vilket innebär att funktioner kan behandlas som förstklassiga medborgare. Detta innebär att de kan skickas som argument, returneras från andra funktioner och tilldelas variabler.
(define (apply-twice f x)
(f (f x)))
(apply-twice add1 5) ; Returnerar 7
Rackets kraftfulla makrosystem möjliggör syntaktiska utvidgningar, vilket gör det möjligt för utvecklare att skapa speciella former som inte finns i bas-språket.
(define-syntax-rule (when condition body)
(if condition
(begin body)))
(when (> 3 2)
(display "3 är större än 2")) ; Utdata: 3 är större än 2
Racket stöder mönstermatchning via match, vilket möjliggör ren och läsbar kod när data destruktureras.
(define (describe lst)
(match lst
[(list 0) "Noll"]
[(list n) (string-append "Ett: " (number->string n))]
[_ "Annat"]))
Racket tillåter funktioner att acceptera ett variabelt antal argument med hjälp av ellips-syntax.
(define (sum . numbers)
(apply + numbers))
(sum 1 2 3 4) ; Returnerar 10
Funktioner i Racket kan ha valfria och nyckelordargument, vilket ger flexibilitet i att definiera funktionssignaturer.
(define (greet #:name [name "Världen"])
(string-append "Hej, " name "!"))
(greet) ; Returnerar "Hej, Världen!"
(greet #:name "Alice") ; Returnerar "Hej, Alice!"
Racket stöder objektorienterad programmering genom sitt class-system, vilket möjliggör skapandet av klasser och metoder.
(define my-class
(class object%
(super-new)
(define/public (greet) "Hej!")))
(define obj (new my-class))
(send obj greet) ; Returnerar "Hej!"
Racket tillhandahåller förstklassiga fortsättningar, vilket gör det möjligt för utvecklare att manipulera kontrollflödet på avancerade sätt.
(define (call-with-current-continuation f)
(call/cc f))
(call-with-current-continuation
(lambda (k) (k 10))) ; Returnerar 10
Racket har inbyggt kontraktsstöd, vilket hjälper utvecklare att specificera förväntat beteende hos funktioner och strukturer.
(define/contract (safe-div x y)
(-> number? (and/c number? (not/c (= y 0))) number?)
(/ x y))
Racket använder ett modulsystem för att underlätta kodorganisation och återanvändbarhet.
(module my-module racket
(define (hello) "Hej från my-module!"))
Typad Racket är en variant av Racket som lägger till statiska typer, vilket möjliggör typkontroll under utvecklingen.
#lang typed/racket
(: add (-> Integer Integer Integer))
(define (add a b) (+ a b))
(add 2 3) ; Returnerar 5
DrRacket fungerar som den primära IDE:n för Racket och erbjuder en integrerad miljö för att skriva och köra Racket-program. Den inkluderar funktioner som syntaxmarkering, felsökningsverktyg och en REPL (Read-Eval-Print Loop) för interaktiv programmering.
Racket har en inbyggd kompilator som kompilerar Racket-kod till bytekod eller maskinkod för effektiv exekvering. Dess körsystem hanterar minne, skräpsamling och andra lågnivåsystemuppgifter.
Att bygga Racket-projekt involverar vanligtvis att organisera kod i moduler och använda Rackets paketssystem för att hantera externa bibliotek. Projekt kan skapas med raco, Rackets kommandoradsverktyg, för att kompilera och köra Racket-filer.
raco make my-project.rkt
raco run my-project.rkt
Racket används inom olika områden, inklusive:
Racket delar likheter med olika programmeringsspråk och betonar sina funktionella programmeringsrötter:
Det finns verktyg som Rackets racket2cpp som möjliggör käll-till-källöversättning från Racket till C++ eller liknande språk. Dessutom har vissa forskningsprojekt fokuserat på att översätta Racket till JavaScript eller Python, vilket möjliggör enklare integration med webbapplikationer eller befintliga system.
Befintliga käll-till-källöversättningsverktyg kan inkludera:
Rackets flexibilitet och starka metaprogrammeringskapabiliteter gör det till en utmärkt kandidat för att bygga språk och utforska nya programmeringsparadigm. Dess rika historia och gemenskapsdrivna utveckling säkerställer att det förblir ett värdefullt verktyg för utbildare, forskare och mjukvaruutvecklare.