Racket er et generelt programmeringssprog, der er en efterkommer af Scheme, som igen er en afledning af Lisp. Oprindeligt designet som en platform til sprogskabelse, tilbyder Racket et rigt sæt værktøjer til udviklere til at definere nye programmeringssprog og hurtigt prototype nye ideer. Det lægger vægt på funktionelle programmeringsparadigmer, og dets kraftfulde makrosystem giver betydelig fleksibilitet i udviklingen af domænespecifikke sprog. Racket er særligt velegnet til uddannelsesmæssige formål, forskning og enhver applikation, der kræver tilpassede sprogfunktioner eller adfærd.
Racket (oprindeligt kaldet PLT Scheme) blev skabt af en gruppe forskere ved Northeastern University i midten af 1990'erne, ledet af Matthew Flatt. Det blev designet som et undervisningsværktøj til at hjælpe studerende med at lære programmering og sprogdesignkoncepter gennem Scheme-dialekten af Lisp. De tidlige versioner af Racket fokuserede primært på at give et robust miljø til undervisning og læring af programmeringssprog.
I de følgende år udviklede Racket sig ud over sine uddannelsesmæssige rødder og blev et generelt programmeringssprog med en distinkt identitet. PLT-teamet omdøbte det til Racket i 2010 og understregede sprogets alsidighed og dets evne til at understøtte forskellige paradigmer, herunder funktionel, imperativ og objektorienteret programmering. Racket-fællesskabet voksede med bidrag fra undervisere, forskere og softwareudviklere, hvilket styrkede dets kapaciteter inden for sprogdesign og udførelse.
I dag har Racket et rigt sæt biblioteker og værktøjer, herunder et kraftfuldt integreret udviklingsmiljø (IDE) kaldet DrRacket. Dets design opfordrer til oprettelse af nye sprog; derfor strækker dets brugerbase sig ud over traditionelle programmeringsanvendelser til sprogeksperimentering og -udvikling. Racket har haft indflydelse i det bredere programmeringssprogssamfund og påvirket sprog som Julia og påvirket udviklingen af uddannelsesmæssige programmeringsmiljøer.
Racket understøtter første-klasse funktioner, hvilket betyder, at funktioner kan behandles som første-klasse borgere. Dette betyder, at de kan sendes som argumenter, returneres fra andre funktioner og tildeles variabler.
(define (apply-twice f x)
(f (f x)))
(apply-twice add1 5) ; Returnerer 7
Rackets kraftfulde makrosystem muliggør syntaktiske udvidelser, der gør det muligt for udviklere at oprette særlige former, der ikke findes i basissproget.
(define-syntax-rule (when condition body)
(if condition
(begin body)))
(when (> 3 2)
(display "3 er større end 2")) ; Udskriver: 3 er større end 2
Racket understøtter mønster matching via match, hvilket muliggør ren og læsbar kode ved destrukturering af data.
(define (describe lst)
(match lst
[(list 0) "Zero"]
[(list n) (string-append "One: " (number->string n))]
[_ "Other"]))
Racket tillader funktioner at acceptere et variabelt antal argumenter ved hjælp af ellipsis-syntaks.
(define (sum . numbers)
(apply + numbers))
(sum 1 2 3 4) ; Returnerer 10
Funktioner i Racket kan have valgfri og nøgleord argumenter, hvilket giver fleksibilitet i definitionen af funktionssignaturer.
(define (greet #:name [name "World"])
(string-append "Hello, " name "!"))
(greet) ; Returnerer "Hello, World!"
(greet #:name "Alice") ; Returnerer "Hello, Alice!"
Racket understøtter objektorienteret programmering gennem sit class system, der muliggør oprettelse af klasser og metoder.
(define my-class
(class object%
(super-new)
(define/public (greet) "Hello!")))
(define obj (new my-class))
(send obj greet) ; Returnerer "Hello!"
Racket giver første-klasse fortsættelser, hvilket gør det muligt for udviklere at manipulere kontrolflow på avancerede måder.
(define (call-with-current-continuation f)
(call/cc f))
(call-with-current-continuation
(lambda (k) (k 10))) ; Returnerer 10
Racket har indbygget kontraktunderstøttelse, der hjælper udviklere med at specificere forventet adfærd af funktioner og strukturer.
(define/contract (safe-div x y)
(-> number? (and/c number? (not/c (= y 0))) number?)
(/ x y))
Racket bruger et modulsystem til at lette kodeorganisation og genanvendelighed.
(module my-module racket
(define (hello) "Hello from my-module!"))
Typed Racket er en variant af Racket, der tilføjer statiske typer, hvilket muliggør typekontrol under udviklingen.
#lang typed/racket
(: add (-> Integer Integer Integer))
(define (add a b) (+ a b))
(add 2 3) ; Returnerer 5
DrRacket fungerer som det primære IDE for Racket og giver et integreret miljø til at skrive og køre Racket-programmer. Det inkluderer funktioner som syntaksfremhævning, fejlfinding og en REPL (Read-Eval-Print Loop) til interaktiv programmering.
Racket har en indbygget compiler, der kompilerer Racket-kode til bytekode eller native maskinkode for effektiv udførelse. Dets kørselssystem håndterer hukommelse, affaldsindsamling og andre lavniveau systemopgaver.
At bygge Racket-projekter involverer typisk at organisere kode i moduler og bruge Racket-pakkesystemet til at administrere eksterne biblioteker. Projekter kan oprettes ved hjælp af raco, Rackets kommandolinjeværktøj, til at kompilere og køre Racket-filer.
raco make my-project.rkt
raco run my-project.rkt
Racket bruges i forskellige domæner, herunder:
Racket deler ligheder med forskellige programmeringssprog og understreger sine funktionelle programmeringsrødder:
Der findes værktøjer som Rackets racket2cpp, der muliggør kilde-til-kilde oversættelse fra Racket til C++ eller lignende sprog. Derudover har nogle forskningsprojekter fokuseret på at oversætte Racket til JavaScript eller Python, hvilket muliggør lettere integration med webapplikationer eller eksisterende systemer.
Eksisterende kilde-til-kilde oversættelsesværktøjer kan inkludere:
Rackets fleksibilitet og stærke metaprogrammeringskapaciteter gør det til en fremragende kandidat til at bygge sprog og udforske nye programmeringsparadigmer. Dets rige historie og fællesskabsdrevne udvikling sikrer, at det forbliver et værdifuldt værktøj for undervisere, forskere og softwareudviklere.