Racket est un langage de programmation généraliste qui est un descendant de Scheme, lui-même dérivé de Lisp. Conçu initialement comme une plateforme pour la création de langages, Racket fournit un ensemble riche d'outils permettant aux développeurs de définir de nouveaux langages de programmation et de prototyper rapidement de nouvelles idées. Il met l'accent sur les paradigmes de programmation fonctionnelle, et son puissant système de macros permet une flexibilité significative dans le développement de langages spécifiques à un domaine. Racket est particulièrement bien adapté à des fins éducatives, à la recherche et à toute application nécessitant des fonctionnalités ou un comportement de langage personnalisés.
Racket (appelé à l'origine PLT Scheme) a été créé par un groupe de chercheurs à l'Université Northeastern au milieu des années 1990, dirigé par Matthew Flatt. Il a été conçu comme un outil éducatif pour aider les étudiants à apprendre les concepts de programmation et de conception de langages à travers le dialecte Scheme de Lisp. Les premières versions de Racket se concentraient principalement sur la fourniture d'un environnement robuste pour l'enseignement et l'apprentissage des langages de programmation.
Au cours des années suivantes, Racket a évolué au-delà de ses racines éducatives, devenant un langage de programmation généraliste avec une identité distincte. L'équipe PLT l'a rebaptisé Racket en 2010, mettant en avant la polyvalence du langage et sa capacité à supporter différents paradigmes, y compris la programmation fonctionnelle, impérative et orientée objet. La communauté Racket a grandi, avec des contributions d'éducateurs, de chercheurs et de développeurs de logiciels, renforçant ses capacités en matière de conception et d'exécution de langages.
Aujourd'hui, Racket dispose d'un ensemble riche de bibliothèques et d'outils, y compris un environnement de développement intégré (IDE) puissant appelé DrRacket. Son design encourage la création de nouveaux langages ; par conséquent, sa base d'utilisateurs s'étend au-delà des cas d'utilisation traditionnels de la programmation vers l'expérimentation et le développement de langages. Racket a eu une influence dans la communauté plus large des langages de programmation, affectant des langages tels que Julia et influençant les développements dans les environnements de programmation éducatifs.
Racket prend en charge les fonctions de première classe, permettant aux fonctions d'être traitées comme des citoyens de première classe. Cela signifie qu'elles peuvent être passées en tant qu'arguments, retournées par d'autres fonctions et assignées à des variables.
(define (apply-twice f x)
(f (f x)))
(apply-twice add1 5) ; Renvoie 7
Le puissant système de macros de Racket permet des extensions syntaxiques, permettant aux développeurs de créer des formes spéciales qui n'existent pas dans le langage de base.
(define-syntax-rule (when condition body)
(if condition
(begin body)))
(when (> 3 2)
(display "3 est plus grand que 2")) ; Affiche : 3 est plus grand que 2
Racket prend en charge la correspondance de modèles via match, permettant un code propre et lisible lors de la déstructuration des données.
(define (describe lst)
(match lst
[(list 0) "Zéro"]
[(list n) (string-append "Un: " (number->string n))]
[_ "Autre"]))
Racket permet aux fonctions d'accepter un nombre variable d'arguments en utilisant la syntaxe des points de suspension.
(define (sum . numbers)
(apply + numbers))
(sum 1 2 3 4) ; Renvoie 10
Les fonctions dans Racket peuvent avoir des arguments optionnels et par mot-clé, offrant une flexibilité dans la définition des signatures de fonction.
(define (greet #:name [name "Monde"])
(string-append "Bonjour, " name "!"))
(greet) ; Renvoie "Bonjour, Monde!"
(greet #:name "Alice") ; Renvoie "Bonjour, Alice!"
Racket prend en charge la programmation orientée objet à travers son système de class, permettant la création de classes et de méthodes.
(define my-class
(class object%
(super-new)
(define/public (greet) "Bonjour!")))
(define obj (new my-class))
(send obj greet) ; Renvoie "Bonjour!"
Racket fournit des continuations de première classe, permettant aux développeurs de manipuler le flux de contrôle de manière avancée.
(define (call-with-current-continuation f)
(call/cc f))
(call-with-current-continuation
(lambda (k) (k 10))) ; Renvoie 10
Racket a un support de contrat intégré, aidant les développeurs à spécifier le comportement attendu des fonctions et des structures.
(define/contract (safe-div x y)
(-> number? (and/c number? (not/c (= y 0))) number?)
(/ x y))
Racket utilise un système de modules pour faciliter l'organisation et la réutilisation du code.
(module my-module racket
(define (hello) "Bonjour depuis my-module!"))
Racket Typé est une variante de Racket qui ajoute des types statiques, permettant la vérification des types pendant le développement.
#lang typed/racket
(: add (-> Integer Integer Integer))
(define (add a b) (+ a b))
(add 2 3) ; Renvoie 5
DrRacket sert d'IDE principal pour Racket, fournissant un environnement intégré pour écrire et exécuter des programmes Racket. Il comprend des fonctionnalités telles que la coloration syntaxique, des outils de débogage et un REPL (Read-Eval-Print Loop) pour la programmation interactive.
Racket dispose d'un compilateur intégré qui compile le code Racket en bytecode ou en code machine natif pour une exécution efficace. Son système d'exécution gère la mémoire, la collecte des ordures et d'autres tâches système de bas niveau.
La construction de projets Racket implique généralement l'organisation du code en modules et l'utilisation du système de paquets Racket pour gérer les bibliothèques externes. Les projets peuvent être créés en utilisant raco, l'outil en ligne de commande de Racket, pour compiler et exécuter des fichiers Racket.
raco make my-project.rkt
raco run my-project.rkt
Racket est utilisé dans divers domaines, notamment :
Racket partage des similitudes avec divers langages de programmation, mettant en avant ses racines en programmation fonctionnelle :
Il existe des outils comme racket2cpp de Racket qui permettent la traduction source-à-source de Racket vers C++ ou des langages similaires. De plus, certains projets de recherche se sont concentrés sur la traduction de Racket vers JavaScript ou Python, facilitant l'intégration avec des applications web ou des systèmes existants.
Les outils de traduction source-à-source existants peuvent inclure :
La flexibilité de Racket et ses fortes capacités de métaprogrammation en font un excellent candidat pour la création de langages et l'exploration de nouveaux paradigmes de programmation. Son histoire riche et son développement axé sur la communauté garantissent qu'il reste un outil précieux pour les éducateurs, les chercheurs et les développeurs de logiciels.