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

[archANJS]

[srm]

Pas exactement, car tu dois avoir deux objets en 2,7, tu en as qu'un toi

[Sephi-Chan]

Écris des tests unitaires. :p

[archANJS]

[srm]

C'est mieux

[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.

[srm]

Quel est l'intérêt de s'affranchir des fonctions disponible pour le langage ?

[niahoo]

Aucun, c'est simplement qu'on n'en a pas besoin.

[niahoo]

Autre implémentation naïve en Haskell

-- Module Skouares

data Square = Square { x :: Int

                     , y :: Int

                     , user :: String

                     } deriving (Show)



square :: Int -> Int -> String -> Square

square x y user = Square {x=x,y=y,user=user}



squareX :: Int -> [Square]

squareX cx = filter ((cx==).x) squares



squareXY :: Int -> Int -> [Square]

squareXY cx cy = filter (((cx,cy)==).xy) squares



xy :: Square -> (Int, Int)

xy a = (x a, y a)



squares :: [Square]

squares = [ 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"

          ]

La même chose sans les records, du coup on crée la fonction x comme accessor en plus

-- Module Skouares

data Square = Square Int Int String deriving (Show)



squareX :: Int -> [Square]

squareX cx = filter ((cx==).x) squares



squareXY :: Int -> Int -> [Square]

squareXY cx cy = filter (((cx,cy)==).xy) squares



xy :: Square -> (Int, Int)

xy (Square x y u) = (x, y)



x :: Square -> Int

x (Square x y u) = x



squares :: [Square]

squares = [ 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"

          ]

[Maks]

dur les syntaxes (ça va à peu près pour haskell)