// Un import, pas besoin d'explication non ? :)

import scala.collection.mutable.HashMap



// La classe principale qui sert à exécuter le test

object Test {



   // Une classe que je créer pour étendre le type de base HashMap

   // afin d'y ajouter un nouveau type de "somme" de tableau

   // et l'argument quelle prend à la construction, 

   // ici HashMap[String, Int] est mon type de tableau associatif, qui a des strings en tant que clé, et des int en tant que valeur

   class HashMapImproved(hm: HashMap[String, Int]) {



      // ici le nom de ma méthode un peu chelou "++=" oui oui lol

      // ma fonction a comme argument une variable hm2 du type HashMap[String, Int]

      // elle va retourner un HashMap[String, Int]

      def +++= (hm2: HashMap[String, Int]): HashMap[String, Int] = {

         // Pas besoin d'explication je pense, c'est un genre de foreach :)

         for ((key,value) <- hm2) {

            // si hm (ma variable de classe, voir plus haut dans la définition de ma classe) contient la clé

            // j'ajoute sa valeur à l'actuelle, sinon je l'assigne directement

            if (hm.contains(key)) {

               hm(key) += value

            } else {

               hm(key) = value

            }

         }

         // je retourne l'objet du coup

         hm

      }

   }



   // Donc ici la méthode principale qui va être exécuté pour faire les tests

   def main(args: Array[String]) {



      // Ca c'est un petit truc magique que l'on peut appeler un peu partout

      // tous les objets du type HashMap vont être automatiquement convertis en objet du type

      // HashMapImproved :)

      implicit def convertHashMap2HashMapImproved(hm: HashMap[String, Int]) = new HashMapImproved(hm)



      // Déclaration de mes variables de test

      val array1 = new HashMap[String, Int]

      val array2 = new HashMap[String, Int]

      val array3 = new HashMap[String, Int]



      // Remplissage de mes tableaux

      array1 += ("nb_cerises" -> 2, "nb_bananes" -> 2, "nb_poires" -> 5)

      array2 += ("nb_cerises" -> 100, "nb_choux" -> 20)

      array3 += ("nb_tomates" -> 30, "nb_bananes" -> 20)



      // Hop j'ajoute le tableau array1 au tableau array2

      array2 +++= array1



      // J'affiche le résultat

      for ((key, value) <- array2) {

         println(key + " : " + value)

      }



      println("-")



      // J'ajoute le tableau array3 au tableau array2

      array2 +++= array3



      // J'affiche le résultat

      for ((key, value) <- array2) {

         println(key + " : " + value)

      }



   }

}

nb_poires : 5

nb_choux : 20

nb_bananes : 2

nb_cerises : 102

-

nb_poires : 5

nb_choux : 20

nb_bananes : 22

nb_tomates : 30

nb_cerises : 102

%%% pour Jeuweb

-module(php_array_add).



%%% Utils

-export([array_add/1]).



%%% Tests

-export([test/0]).



test() ->

	Array1 = [{trucs, 12},{machins, 3},{choses, -4}],

	Array2 = [{machins, 1},{choses, 80}, {'FAIL!', "pas un int()"}],

	Array3 = [{machins, 12},{bidules, 24},{trucs, "ici non plus"}],

	array_add([Array1, Array2, Array3]).



%% Si un seul tableau est passé on le retourne

array_add([Ar|[]]) -> Ar;



%% Quand il ne reste que 2 tableaux à traiter, on renvoie leur "somme"

array_add([A1, A2|[]]) -> addition(A1,A2);



%% ici on pioche les deux premiers tableaux de la liste

%% et on repose leur "somme" sur la liste

array_add([A1, A2|Arrays]) -> array_add([addition(A1,A2)|Arrays]).





%% ici on se sert d'un accumulateur Acc, il joue le rôle de $result

addition(A1, A2) -> addition(A1, A2, []).



%% cette fonction n'est pas du tout performante, c'est pour l'exemple,

%% ici on parcourt maintes fois A2, bien plus que nécessaire

addition([], A2, Acc) -> A2 ++ Acc;

addition([{Key, Value}|A1], A2, Acc) when is_integer(Value)-> 



	ToAdd = case proplists:get_value(Key, A2, 0) of

		X when is_integer(X) -> X;

		_ -> 0

	end, 



	NewPair = {Key, Value + ToAdd},

	addition(A1, proplists:delete(Key, A2), [NewPair|Acc]);



%% Si la value n'est pas un entier, j'ai pris comme parti de la zapper

addition([{_Key, _Value}|A1], A2, Acc) -> addition(A1, A2, Acc).

29> c(php_array_add).    

{ok,php_array_add}

30> php_array_add:test().

[{bidules,24},{trucs,12},{machins,16},{choses,76}]

31>

-module(jeuweb).

-export([dict_melt/1,test/0,add_only_int/3]).



dict_melt([]) ->

    dict:new();

dict_melt([Dict|[]]) ->

    dict:to_list(Dict);

dict_melt([Dict1,Dict2|Dicts]) ->

    dict_melt([melt(Dict1,Dict2)|Dicts]).



melt(D1,D2) ->

    dict:merge(fun(K,V,VV)->add_only_int(K,V,VV) end, D1, D2).



add_only_int(_K, V1, V2) when is_integer(V1), is_integer(V2) ->

    V1 + V2;

add_only_int(_K, V1, _V2) when is_integer(V1) -> V1;

add_only_int(_K, _V1, V2) when is_integer(V2) -> V2.



test() ->

    Arrays = [

	      [{trucs, 12},{machins, 3},{choses, -4}],

	      [{machins, 1},{choses, 80}, {'FAIL!', "pas un int()"}],

	      [{machins, 12},{bidules, 24},{trucs, "ici non plus"}]

	     ],

    

    dict_melt(lists:map(fun(L) -> dict:from_list(L) end, Arrays)).