Iteraptor: bibliothèque pour redus de carte transparent profond

Les structures de données Elixir sont immuables. C'est génial du point de vue de la confiance que nos données ne seront pas corrompues au-delà de la reconnaissance dans un autre morceau de code non pertinent, mais c'est un peu ennuyeux lorsque nous devons changer une structure profondément imbriquée.

Nous avons une brillante abstraction Access , qui simplifie considérablement quatre opérations de base sur des objets profondément imbriqués en utilisant les fonctions exportées par défaut du Kernel :

• Kernel.get_in/2
• Kernel.put_in/{2,3}
• Kernel.update_in/{2,3}
• Kernel.pop_in/{1,2}

Ces quatre mousquetaires (et d'Artagnan Kernel.get_and_update_in/{2,3} sont généralement utilisés quelque chose comme ceci:

 iex> users = %{"john" => %{age: 27, mood: ""}, "meg" => %{age: 23}} #   iex> get_in(users, ["john", :age]) #⇒ 27 #   iex> put_in(users, ["john", :age], 28) #⇒ %{"john" => %{age: 28, mood: ""}, "meg" => %{age: 23}} #   iex> update_in(users, ["john", :mood], & &1 + 1) #⇒ %{"john" => %{age: 28, mood: ""}, "meg" => %{age: 23}} #   iex> pop_in(users, ["john", :mood]) #⇒ {"", %{"john" => %{age: 27}, "meg" => %{age: 23}}} 

Il est pratique et fonctionne dans de nombreux cas ... sauf pour ceux où cela ne fonctionne pas. Pour utiliser Access , vous devez connaître le chemin d'accès à l'élément cible, et tout cela nécessite une quantité importante de code passe-partout afin de mettre à jour plusieurs valeurs imbriquées à la fois (par exemple, supprimez toutes les feuilles avec la valeur nil ou mettez en étoile le contenu de tous les champs qui n'ont pas besoin d'être affichés dans les journaux).

Pour offrir des remises en gros sur l'utilisation de structures imbriquées, la bibliothèque Iteraptor a été créée.

TL; DR:

• codes sources ;
• la documentation .

Itérer tout ce que vous pouvez répéter comme par magie à Elixir . Pour le rendre itérable, implémentez simplement le protocole Enumerable pour ce type particulier. Vous pouvez regrouper les passages en pipelines, cartographier, réduire, filtrer, éclaircir ... Pardonnez mon français, oui. Tous ceux qui ont passé au moins huit heures avec Elixir ont certainement vu (et peut-être même écrit) quelque chose comme ceci:

 ~w|   | |> Enum.map(&String.capitalize/1) |> Enum.each(fn capitalized_name -> IO.puts "Hello, #{capitalized_name}!" end) # Hello, ! # Hello, ! # Hello, ! # Hello, ! 

C'est vraiment très pratique. Cependant, le code devient rapidement lourd lorsqu'il s'agit de structures profondément imbriquées, telles qu'une carte avec des mots - clés imbriqués, des listes, etc. Un bon exemple de ceci est tout fichier de configuration contenant des sous-sections imbriquées.

Le nombre de questions sur Stack Overflow avec la question «comment puis-je changer la structure imbriquée?» M'a forcé à enfin créer cette bibliothèque. La mise en œuvre chez Elixir semble un peu déroutante, car tout autour est immuable, et vous ne pouvez pas simplement descendre les branches de la structure jusqu'aux feuilles, en changeant tout ce dont vous avez besoin en place. Vous aurez besoin d'une batterie, comme, cependant, sous n'importe quel capot d'un code fonctionnel. Changer les structures imbriquées est probablement le seul exemple que j'ai vu dans ma vie où la mutabilité facilite les choses.

En plus des précurseurs de carte habituels, j'ai ajouté une implémentation pour stocker la valeur au plus profond de la structure, ce qui crée des clés intermédiaires selon les besoins. Il se comporte comme proposé, mais rejeté dans le noyau rubis Hash#bury . Cette bibliothèque sait également comment "jasoniser" des structures imbriquées contenant des mots clés qui ne peuvent pas être simplement sérialisés en json , car à l'intérieur, ils sont présentés comme des listes de tuples à deux éléments ( [foo: :bar] == [{:foo, :bar}] ), et les tuples ne sont pas sérialisables hors de la boîte.

Alors, saluons la bibliothèque, qui itère sur n'importe quelle carte / mot - clé / liste dans la queue et la crinière est presque aussi simple que les Enum.each/2 et Enum.map/2 .

Les possibilités

• Iteraptor.each/3 simple itération, retourne la structure elle-même;
• Iteraptor.map/3 mappage Iteraptor.map/3 , renvoie une structure mappée;
• Iteraptor.reduce/4 reduus, renvoie la batterie;
• Iteraptor.map_reduce/4 map et redus, renvoie un tuple avec le résultat de la cartographie et de la batterie;
• Iteraptor.filter/3 filtre la structure en utilisant la fonction obtenue par le dernier paramètre;
• Iteraptor.jsonify/2 prépare la structure pour la sérialisation en json : tous les mots clés sont remplacés par des cartes , les clés sont converties en chaînes;
• Iteraptor.Extras.bury/4 écrit la valeur profondément dans la structure, créant des clés intermédiaires selon les besoins;
• Iteraptor.to_flatmap/2 transforme la structure en une structure plate, créant soigneusement des index pour les listes; la structure d'origine peut être récupérée en utilisant
• Iteraptor.from_flatmap/3 transforme une structure platunk avec des clés concaténées en une structure profondément imbriquée;
• use Iteraptor.Iteraptable implémentation automatique des protocoles Enumerable et Collectable , ainsi que le comportement Access pour la structure. Il y a une description plus détaillée de ce qui est sous le capot.

Les mots ne coûtent rien, montrez le code!

Itération, cartographie, réduction

 # each iex> %{a: %{b: %{c: 42}}} |> Iteraptor.each(&IO.inspect(&1, label: "each"), yield: :all) # each: {[:a], %{b: %{c: 42}}} # each: {[:a, :b], %{c: 42}} # each: {[:a, :b, :c], 42} %{a: %{b: %{c: 42}}} # map iex> %{a: %{b: %{c: 42}}} |> Iteraptor.map(fn {k, _} -> Enum.join(k) end) %{a: %{b: %{c: "abc"}}} iex> %{a: %{b: %{c: 42}, d: "some"}} ...> |> Iteraptor.map(fn ...> {[_], _} = self -> self ...> {[_, _], _} -> "********" ...> end, yield: :all) %{a: %{b: "********", d: "some"}} # reduce iex> %{a: %{b: %{c: 42}}} ...> |> Iteraptor.reduce([], fn {k, _}, acc -> ...> [Enum.join(k, "_") | acc] ...> end, yield: :all) ...> |> :lists.reverse() ["a", "a_b", "a_b_c"] # map-reduce iex> %{a: %{b: %{c: 42}}} ...> |> Iteraptor.map_reduce([], fn ...> {k, %{} = v}, acc -> {​{k, v}, [Enum.join(k, ".") | acc]} ...> {k, v}, acc -> {​{k, v * 2}, [Enum.join(k, ".") <> "=" | acc]} ...> end, yield: :all) {​%{a: %{b: %{c: 42}}}, ["abc=", "ab", "a"]} # filter iex> %{a: %{b: 42, e: %{f: 3.14, c: 42}, d: %{c: 42}}, c: 42, d: 3.14} ...> |> Iteraptor.filter(fn {key, _} -> :c in key end, yield: :none) %{a: %{e: %{c: 42}, d: %{c: 42}}, c: 42} 

Imbrication profonde → structure plate et vice versa

 iex> %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}} ...> |> Iteraptor.to_flatmap(delimiter: "_") #⇒ %{"a_b_c" => 42, "a_b_d_0" => nil, "a_b_d_1" => 42, "a_e_0" => :f, "a_e_1" => 42} iex> %{"abc": 42, "abd0": nil, "abd1": 42, "ae0": :f, "ae1": 42} ...> |> Iteraptor.from_flatmap #⇒ %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}} 

Brioches

 iex> Iteraptor.jsonify([foo: [bar: [baz: :zoo], boo: 42]], values: true) %{"foo" => %{"bar" => %{"baz" => "zoo"}, "boo" => 42}} iex> Iteraptor.Extras.bury([foo: :bar], ~w|abcd|a, 42) [a: [b: [c: [d: 42]]], foo: :bar] 

Les sources sont ouvertes , la documentation est assez détaillée , nous sommes en production depuis près de deux ans maintenant.

Bonne itération!