[All/Scala] Trier de coordonnées dans un tableau à deux dimensions

[niahoo]

Voilà un exemple plus simpliste du problème qui permet d'entrevoir les tests unitaires et les spécifications de types sur des exemples simples.

-module(xy).

-include_lib("eunit/include/eunit.hrl").



%% API

-export([square/3,byX/2,byXY/3]).



%% Tests

-export([t/0]).



-type user() :: string() | iolist().

-type square() :: {integer(), integer(), user()}.



-spec square(integer(), integer(), user()) -> square().

square(X,Y,User) -> {X,Y,User}.







-spec byX([square()], integer()) -> [square()].

byX(Squares,X) ->

    byX(Squares,[],X).



-spec byX([square()], [square()], integer()) -> [square()].

byX([], Found, _) -> Found;

byX([{X,_,_}=SQ|SQs], Found, X) ->

    byX(SQs, [SQ|Found], X);

byX([{_X,_,_}|SQs], Found, X) ->

    byX(SQs, Found, X).



-spec byXY([square()], integer(), integer()) -> [square()].

byXY(Squares,X,Y) ->

    byXY(Squares,[],X,Y).



-spec byXY([square()], [square()], integer(), integer()) -> [square()].

byXY([], Found, _, _) -> Found;

byXY([{X,Y,_}=SQ|SQs], Found, X, Y) ->

    byXY(SQs, [SQ|Found], X, Y);

byXY([{_X,_,_}|SQs], Found, X, Y) ->

    byXY(SQs, Found, X, Y).





main_test_() ->

    [ { "Création d'un square",

        [?_assertMatch({1,2,"Hello"},square(1,2,"Hello"))]

      }

    , { "Recherche des squares par X et par XY"

      , setup, fun t/0

      , fun(Squares) ->

            Twos = listsort(xy:byX(Squares,2)),

            Fours = listsort(xy:byX(Squares,4)),

            FourSevens = listsort(xy:byXY(Squares,4,7)),

            [ ?_assertMatch([], xy:byX(Squares,10))

            , ?_assertEqual(

                [{2,2,"oxman"},{2,7,"Sephi-Chan"},{2,7,"Sephi-Chan"}],

                Twos

            )

            , ?_assertEqual(

                [{4,4,"oxman"},{4,6,"oxman"},{4,7,"Sephi-Chan"}],

                Fours

            )

            , ?_assertEqual(

                [{4,7,"Sephi-Chan"}],

                FourSevens

            )

            , ?_assertMatch([], xy:byXY(Squares,4,10))

            ]

       end

      }

    ].







t() -> [

    square(2, 2, "oxman"),

    square(4, 6, "oxman"),

    square(4, 7, "Sephi-Chan"),

    square(2, 7, "Sephi-Chan"),

    square(4, 4, "oxman"),

    square(2, 7, "Sephi-Chan")

].

Et comme en couleurs c'est toujours plus sympa : http://paste.bouh.org/696b247378cf4d4082935657daf7d5e2

(PS: oxman pas tip top le thème de coloration à mon goût, ce serait cool de pouvoir switcher =D )


Par rapport à l'exemple en Scala on pourrait croire, vu la masse de code supplémentaire, que c'est bien compliqué pour pas grand chose.

Mais contrairement à mon exemple précédent, on ne fait aucun appel à des fonctions externes au module*, pas de lists:fold(), et pas de .groupBy() ni de .mapValues(). Tout le code qui sera exécuté est ce qui est présenté ici.

* Excepté dans les tests.