DojoDeveloppement/Mercredi4Janvier2012

• EmmanuelGaillot
• JonathanPerret
• ChristopheThibaut
• AlinePaponaud?
• YannickFrancois
• RomainGauthier?

La dernière fois, c'était l'année dernière, le /Mercredi21Decembre2011 :

• Randori /Labyrinthe? en Haskell
• On n'a pas fini. En fait, on a à peine commencé. On a beaucoup erré / niaisé...
  • On a été lentement. Sans plan.
  • Manque de familiarité avec Haskell ? Emacs ? Le mode vi(per) de Emacs ? Le kata ? L'algo de résolution de labyrinthe ? Autant d'éléments perturbateurs...
• Sur la fin, Jonathan a pris le volant... et certes ça a été plus vite - mais Christophe a décroché.
  • Quand Jonathan frustré, lui toujours agir ainsi.
  • (mais pas que lui ?)
• Donc -
  • "Fais un plan"
  • Emacs vs. vi, c'est chiant. Besoin de passer à un "éditeur neutre". Mais nivellement par le bas ? Mais finalement, est-ce important ? Mais alors, pourquoi en parle-t-on autant ? Allez hop, on passe à TextMate? (ou équivalent) (au moins pour les randoris).
  • Cet exercice peut prendre plusieurs chemins... et peut-être qu'il y en a de plus efficaces que d'autres.
  • Quand les tests sont haut niveau pour piloter du code bas niveau, cela entraîne un problème de rythme. Et du coup, si on prend une approche top-down, rester cohérent avec cette approche.
  • Plutôt que de commencer par chercher la sortie, commencer par chercher les (début de) chemins possibles à partir d'où je suis.

Bon. Ce soir :

• Kata /Labyrinthe? en Haskell (Sujet retenu)
• Randori "Ruby Christmas Contest" (http://contest.dimelo.com/)... en Ruby (sous TextMate?)

module Tests
where

import Test.HUnit
import Maze

main = runTestTT tests
tests = TestList [
         let m = Maze (0,0) (0,1) [(0,0),(0,1)]
             v = [(0,0)]
         in Maze.path m v ~?= [East],

         let m = Maze (0,0) (0,2) [(0,0),(0,2)]
             v = [(0,0)]
         in Maze.path m v ~?= [],

         let m = Maze (0,1) (0,2) [(0,0),(0,1),(0,2)]
             v = [(0,0),(0,1)]
         in Maze.path m v ~?= [],

         let m = Maze (0,1) (0,0) [(0,0),(0,1)]
             v = [(0,1)]
         in Maze.path m v ~?= [West],

         let m = Maze (0,0) (1,0) [(0,0),(1,0)]
             v = [(0,0)]
         in Maze.path m v ~?= [South],

         let m = Maze (1,0) (0,0) [(0,0),(1,0)]
             v = [(1,0)]
         in Maze.path m v ~?= [North],

         let m = Maze (0,1) (0,2) [(0,0),(0,1),(0,2)]
             v = [(0,1)]
         in Maze.path m v ~?= [East],

         let m = Maze (0,0) (0,2) [(0,0),(0,1),(0,2)]
             v = [(0,0)]
         in Maze.path m v ~?= [East,East]
       ]

module Maze (Maze (..), Direction (..), path)
where
import Data.List

data Maze = Maze { entry    :: Point,
                   exit     :: Point,
                   passages :: [Point] }

type Point = (Int,Int)
type Path = [Direction] 
data Direction = East | West | South | North
                 deriving (Eq, Show)

dirs = [East,West,South,North]

path :: Maze ->  [Point] -> Path
path m@(Maze (0,0) (0,2) [(0,0),(0,1),(0,2)]) vs@[v@(0,0)] = 
  concat [[d] ++ path m (v `going` d:vs) | d <- dirs,
         not (null (path m (v `going` d:vs))) ]

path m vs = case successDirections m vs of
              [] -> []
              sd -> [head sd]


successDirections m (v:vs) = 
    [d | d <- dirs,
     let v' = (v `going` d)
     in visitable v' && v' == (exit m)] 
    where
      visitable p = p `elem` ((passages m) \\ vs)

going :: Point -> Direction -> Point
going (r,c) East = (r,c+1)
going (r,c) West = (r,c-1)
going (r,c) South = (r+1,c)
going (r,c) North = (r-1,c)