Récemment (dans mon esprit) le sujet d'Elixir. C'est un langage fonctionnel moderne qui n'est pas aussi robuste que Haskell. Elixir a de nombreux charmes, mais parmi eux, le traitement des fonctions de pipe est en moi. Je l'aime beaucoup.
Un tel mec
[1, [2], 3, [4, 5] |> List.flatten |> Enum.map(&(&1 * 2))
Vous pouvez transmettre la valeur de retour à la fonction de droite en utilisant l'opérateur «|>».
J'utilise Python et j'aimerais pouvoir créer plusieurs fonctions comme ci-dessus.
Je l'ai fait comme ça.
def hoge(a, b, c, d) :
return a+b+c+d
pipe([1,2],
[
pmap(lambda x: x*2),
list,
to(hoge, [3, 4]),
print
]
)
pipe / 2, to / 2, pmap / 1 sont ceux que j'ai créés. Chaque rôle est pipe Le premier argument est la valeur initiale du traitement du tube et le deuxième argument est la liste des fonctions. La mise en œuvre est
from functools import reduce
def pipe(elm, fn_list) :
return reduce(lambda x, f: f(x), fn_list, elm)
to Une fonction d'ordre supérieur qui convertit une fonction auto-créée en une forme adaptée à une fonction de tube. La mise en œuvre est
def to(fn, outer_args=None) :
def _to(inner_args) :
args = outer_args+inner_args if not outer_args == None else inner_args
return fn(*args)
return _to
pmap Fonction de carte existante enveloppée pour la fonction de tuyau En plus de cela, réduire et filtrer sont également fabriqués, mais pour le moment
La mise en œuvre est
def pmap(fn) :
def _pmap(li) :
return map(fn, li)
return _pmap
Je suis satisfait parce que j'ai pu faire ce que je voulais faire simplement en faisant quelque chose d'assez simple. Cependant, le style d'écriture est très différent du style d'écriture standard, j'ai donc pensé que je ne pouvais l'utiliser qu'avec mon propre code.
Recommended Posts