Mise à jour de Translib: version 0.2.0

Une petite mise à jour du projet. Au menu, 2 nouveaux modules:

  • clone_module: Il s’agit d’un transformer permettant de cloner des modules Erlang existant afin d’en modifier (légèrement) le comportement. La documentation en dit plus.
  • transhell: C’est un clone du shell Erlang. Il utilise le transformer clone_module pour ça. Ce module rempli exactement les mêmes fonctions que le shell Erlang à ceci près qu’il transforme les expressions avant leur évaluation. On passe par le transformer multiparser pour cela.

Voir: Mes projets

Translib version 0.1.0

Suite à mon article précédent sur un parser d’expressions lambda en Erlang, J’ai pris un peu de temps pour mieux formaliser mon travail et produire un code un peu plus clean. J’ai donc créé le projet translib (pour Transformer Library).

Translib est une bibliothèque Erlang contenant plusieurs transformers, dont celui utilisé pour les expressions lambda, mais aussi un behaviour aidant à la création de nouveaux transformers.

L’application Translib est disponible sur google code. La documentation, qui est pour le moment incomplète, est disponible aussi ici

Pour le moment, l’application contient 4 modules:

  • gen_trans: un behaviour contenant un parser générique facilitant l’écriture de transformers. Il est utilisé au sein de translib comme base pour les modules recfun et lambda_expr.
  • recfun: transformer permettant l’écriture de fonctions récursives anonymes. Je reviendrais sans doute dessus dans un futur article. En attendant la documentation du module permet de se faire une idée de la manière dont il fonctionne.
  • lambda_expr: transformer d’expressions lambda en Erlang. Il facilite l’écriture d’applications partielles et de compositions de fonctions.
  • multiparser: transformer permettant de mettre en place une chaîne de transformation. Chaque maillon est un module qui doit implémenter le behaviour gen_trans.

Lambda_expr: un parser d’expressions lambda

Sous ce nom un peu emphatique se cache une tentative de rendre l’écriture de certaines formes d’expressions lambda en Erlang plus intuitive. Je me suis concentré principalement sur la composition1 et l’application partielle2 de fonctions.

En Erlang, les expressions lambda prennent la forme de fonctions anonymes créées en utilisant le mot clés fun :

fun(X) -> 2 * X end.
fun lists:map/2.

Comme tout langage fonctionnel qui se respecte, Erlang gère ces expressions comme des variables capturant l’environnement3 dans lequel elles sont définies:

adder(N) ->
  fun(X) ->
    N + X     %% N est une variable lié
  end.

Néanmoins, certaines opérations, telle que la composition de fonctions ou l’application partielle, nécessitent une écriture assez prolixe. Pour effectuer la composition F o G, il faudrait écrire quelque chose du genre:

fun(X, Y, ...) -> F(G(X, Y, ...)) end.

De même, les applications partielles doivent être écrites comme de nouvelles fonctions:

F = fun(X, Y) -> X + Y end.
G = fun lists:map/2.

F1 = fun(X) -> F(X, 1) end.
G1 = fun(L) -> lists:map(F1, L) end.

Le résultat n’est pas franchement intuitif et ne suggère pas qu’il s’agisse de compositions dans le premier cas, ou d’applications partielles dans le second. C’est ce que j’aimerais changer avec le parser lambda_expr.
Read more

  1. Function compositon in computer science []
  2. Patial application in Haskell []
  3. En informatique on parle de closure []

Tableaux anonymes en C

Une petite technique qu’un ami m’a fait découvrir il y a quelques temps. Et c’est bien connu, ce sont les tips les plus simples qui servent le plus. En l’occurrence, celui-ci me sert au quotidien tellement il est pratique et élégant. Il s’agit des tableaux anonymes en C. La syntaxe n’est pas bien compliquée, mais elle terriblement difficile à retenir (bizarrement) et très efficace.

Cette technique permet de remplacer le code suivant :

void my_func(int *value) { /*...*/ }
 
int value = 1;
my_func(&value);

Par :

void my_func(int *value) { /*...*/ }
 
my_func((int[]){1});

Voici la source : kung-f00

Erlstream: Stream Processing Functions

Stream est un module Erlang permettant de travailler sur des binaires de la même manière que sur les chaînes de caractères.

J’ai développé ce module sur le modèle du module string.erl. On y retrouve à peu de chose près les mêmes fonctions. Ainsi il est possible de rechercher des séquences dans un binaire, de tronquer un binaire, de découper le binaire en une liste de binaire…

Voici quelques exemple d’utilisation du module stream.erl:

%% Return <<"lo Wo">>
stream:substream(<<"Hello World">>, 4, 8).

%% Return <<"Hello">>
stream:strip(<<"...Hello.....">>, both, $.).

%% Return [<<"abc">>, <<"def">>, <<"ghi">>, <<"jkl">>]
stream:tokens(<<"abc defxxghix jkl">>, <<"x ">>).

Source: module stream.erl, documentation du module stream.erl

Return top
 
Better Tag Cloud