Unlambda

Le Unlambda est un langage de programmation fonctionnel de du minimal inventé par le David Madore . Il est basé sur la logique combinatoire , une version de du calcul du lambda qui omet l'opérateur de lambda. Il se fonde principalement sur deux fonctions intégrées ( s et k ) et un " ; apply" ; opérateur (écrit ` de , le caractère de backquote). Ces seuls lui font le Turing-complet, mais il y a également quelques fonctions d'entrée-sortie pour permettre pour agir l'un sur l'autre avec l'utilisateur, quelques fonctions de raccourci et une fonction pour l'évaluation paresseuse.

Comme langage de programmation ésotérique , Unlambda est signifié comme démonstration de la programmation fonctionnelle très pure plutôt que pour l'usage pratique. Sa caractéristique principale est le manque d'opérateurs et de types courants &mdash de données ; le seul genre de données dans le programme sont des fonctions d'un-paramètre. Des données peuvent néanmoins être simulées avec des fonctions appropriées comme dans le calcul du lambda. Des fonctions de multiparamètre peuvent être représentées avec la technique du corroyant .

Unlambda est basé autour du principe de l'élimination d'abstraction de , ou de l'élimination de toutes les variables sauvées, y compris des fonctions. Comme langue pur-fonctionnelle, sont non seulement les objets de première classe des fonctions d'Unlambda, ils sont les objets de première classe du seulement .

Une exécution du programme du monde de bonjour dans Unlambda suit :

```````````du `r.di

Le de notation. le X dénote une fonction qui prend un argument et le renvoie sans changement, impression le simple de caractère X comme effet secondaire quand il est appelé. i représente la version de la fonction d'identité qui n'a aucun un tel effet secondaire ; il est employé ici comme argument factice.di de de programme s'applique la fonction de d-printing à un argument factice de i, de i de renvoi et d'impression la lettre d comme effet secondaire. De même, le ``.di s'applique d'abord .d, à impression la lettre l et à .d de renvoi ; ce résultat de .d est alors appliqué à i comme dans l'exemple précédent. La fonction r est le sucre syntactique pour la fonction qui imprime un caractère de caractère NL.

D'autres dispositifs importants ont fourni par Unlambda incluent les fonctions de k et de s. k fabrique des fonctions constantes : le résultat du X du `k de est une fonction qui, une fois appelée, renvoie le X . Ainsi la valeur de x/y de k de le ``est le X pour n'importe quel X et y .

s est un opérateur généralisé d'évaluation. le xyz de du ```s de évalue le yz de de `du xz de à `` pour n'importe quel X , y , et z . C'est un fait remarquable que s et k sont suffisants pour exécuter n'importe quel calcul ; voir l'article du calcul de combinator de SKI de pour les détails complets. Comme bref exemple, noter que la fonction d'identité i peut être mise en application comme ``skk, puisque le X de SKK de ```de rapporte le X pour tout le X .

Une construction de contrôle de flux d'Unlambda est appel de avec la suite courante , c dénoté. Quand une expression du X du `c de de forme est évaluée, un " spécial ; continuation" ; l'objet est construit, représentant l'état de l'interprète à ce moment. Alors le X est évalué, et alors le résultat est donné l'objet de suite comme argument. Si la suite n'est jamais appliquée à un argument, la valeur de l'expression du X du `c de est identique que la valeur du X . Mais si l'objet de suite est appliqué à un y de valeur, l'exécution du X est immédiatement avortée, et la valeur de l'expression entière du X du `c de est le y .

Bien que la sémantique de l'exécution d'Unlambda soient normalement le désireux, il y a une option de l'évaluation paresseuse , indiquée en employant l'opérateur de d. Habituellement, pour évaluer une expression du de x/y de `de de forme, l'unlambda évalue d'abord le X , puis le y , et applique ensuite le X au y . Cependant, si le X évalue à la valeur spéciale d, puis le y est le pas évalué ; au lieu de cela, la valeur du y du `d de d'expression est un " spécial ; computation" retardé ; objecter, qui, une fois appliqué à un z d'argument, évalue le y , et puis s'applique sa valeur au z . Noter qu'en l'absence des effets secondaires, c'est exactement le même que le y du `i de . La différence est ce y du `i de exécute tous les effets secondaires en y immédiatement, tandis que le y du `d de reporte les effets secondaires jusqu'à ce que le résultat soit appliqué à un autre argument.

Le prochain opérateur intégré d'Unlambda est v, qui ignore son argument et renvoie v. Ce dispositif n'est pas strictement nécessaire, puisque v pourrait être mis en application comme ```s ``k ``le SII ``s ``le `k ``siik de de ksk de `de s, mais il est fourni comme convenance. (Cette expression ci-dessus est simplement le `Yk de , où Y dénote un combinator de point fixe de .)

L'entrée dans Unlambda est facilitée par les opérateurs @ et le ? u . Quand @ est appliqué à un X de fonction, un caractère est lu de l'entrée, et stocké comme " ; character" courant ; ; alors le X est appliqué à i. Cependant, si plus de caractères n'étaient disponibles sur l'entrée, le " ; character" courant ; est laissé non défini, et le X est appliqué à v à la place. Quand un de fonction ? le u est appliqué à un X de fonction, le résultat est l'évaluation du X i de `de si le caractère courant est le u , autrement le X v de `de est évalué.

Il y a également un " ; reprint" ; d'opérateur|. Quand `de | le X est évalué, le X de fonction est appliqué au . u si le u est le caractère courant, ou à v s'il n'y a aucun caractère courant.

En conclusion, il y a un opérateur e de sortie. Quand e est appliqué au X , l'exécution du programme est terminée, et le X est pris pendant que le résultat du programme (la plupart des interprètes actuellement existants ignorent le résultat de toute façon).

Voir également