port des for_comprehension de scala en ruby

=> https://linuxfr.org/users/yazgoo/journaux/port-des-for_comprehension-de-scala-en-ruby

2025-01-04 00:48 UTC,

Sommaire

• [contexte:

map

et

flatMap

]

=> #toc-contexte-map-et-flatmap

• [exemples de

map

]

=> #toc-exemples-de-map

• [exemples de

flatMap

]

=> #toc-exemples-de-flatmap

• [contexte: programmes fonctionnels]

=> #toc-contexte-programmes-fonctionnels

• [for comprehensions]

=> #toc-for-comprehensions

• [port en ruby]

=> #toc-port-en-ruby

• [implémentation de

for_c

]

=> #toc-impl%C3%A9mentation-de-for_c

• [conclusion]

=> #toc-conclusion

contexte:

map

et

flatMap

Scala est un langage fonctionnel, et donc les operateurs

map

et

flatMap

sont très utilisés.

Pour rappel:

map

perment d'appliquer une fonction à chaque élément d'une structure de données.

flatMap

permet d'appliquer une fonction qui retourne une structure de données à chaque élément d'une structure de données, et de "déplier" le résultat.

Cela s'applique à des liste, mais pas seulement.

exemples de

map

Avec une liste:

vallist=List(1,2,3)valresult=list.map(x=>x*2)// result: List(2, 4, 6)

Avec un

Option

:

valoption=Some(1)valresult=option.map(x=>x2)// result: Some(2)valoption=Nonevalresult=option.map(x=>x2)// result: None

exemples de

flatMap

Avec une liste:

vallist=List(1,2,3)valresult=list.flatMap(x=>List(x,x*2))// result: List(1, 2, 2, 4, 3, 6)

Avec un

Either

(un type qui peut contenir soit une valeur (auquel cas, c'est un Right) ou une erreur (Left)):

valeither=Right(1)valresult=either.flatMap(x=>Right(x2))// result: Right(2)valeither=Left("error")valresult=either.flatMap(x=>Right(x2))// result: Left("error")

contexte: programmes fonctionnels

En scala, on chaine souvent

map

,

flatMap

et

filter

pour écrire des programmes fonctionnels.

Par exemple, supposons que l'on veuille calculer tous les tuples de 0 à 9 dont la somme est égale à 10:

valresult=(0to9).flatMap{x=>(0to9).map{y=>(x,y)}}.filter{case(x,y)=>x+y==10}// result: Vector((1,9), (2,8), (3,7), (4,6), (5,5), (6,4), (7,3), (8,2), (9,1))

for comprehensions

On voit que cela devient rapidement difficile à lire. Pour cela, Scala propose les

for comprehensions

, qui permettent d'écrire du code plus lisible.

Avec une for comprehension, le code précédent devient:

valresult=for{xvalue})for_comprehension(tail,new_env,&block)endendend

Pour les curieux, l'implémentation complète de

for_c

est disponible sur [gist.github.com]

=> https://gist.github.com/yazgoo/e897b5d31b0fae7bb0b299c6a1225ecd

,

conclusion

Le lecteur jugera de la pertinence d'utiliser cette syntaxe ainsi que de sa lisibilité.

Le code n'est pas du tout optimisé, cela reste une expérimentation.

Je suis en train de m'amuser à implémenter des effets (IOs) à la Haskell/cats effects/ZIO en ruby,

et cette syntaxe simplifiera grandement le code.

[Télécharger ce contenu au format EPUB]

=> https://linuxfr.org/users/yazgoo/journaux/port-des-for_comprehension-de-scala-en-ruby.epub

Commentaires : [voir le flux Atom]

=> //linuxfr.org/nodes/137847/comments.atom

[ouvrir dans le navigateur]

=> https://linuxfr.org/users/yazgoo/journaux/port-des-for_comprehension-de-scala-en-ruby#comments

=> ..