Surcharge d'opérateur sur un type de donnée user-defined

Salut,

Etant en apprentissage depuis deux jours de Haskell, je me raccroche à mes habitudes de programmation en d'autres langages, principalement Python. Je suis donc habitué aux langages orientés objet, donc signalez moi si vous voyez une erreur de conception ou une architecture/vocabulaire non adapté au paradigme fonctionnel. Voici mon problème: j'essaie de définir un type de donnée dont on pourrait ajouter les instances avec l'opérateur classique +. Plus précisément, j'ai un type de donnée Position et un autre Direction.

Ils sont définis comme suit:

1
2
3
4
5
6
7

data Position = Position {
    x :: Int,
    y :: Int
} deriving Show

-- North | South | East | West
data Direction = N | S | E | W deriving Show

Maintenant j'aimerais que si je tape Position { x = 5, y = 6 } + N, j'obtienne Position { x = 5, y = 5 }.

J'ai essayé tout simplement de définir l'opérateur `(+)' avec la signature (+) :: Position -> Direction -> Position:

1
2
3
4
5

position + direction = case direction of
                           N -> Position { x = x position,     y = y position - 1 }
                           S -> Position { x = x position,     y = y position + 1 }
                           E -> Position { x = x position + 1, y = y position     }
                           W -> Position { x = x position - 1, y = y position     }

Evidemment Haskell me dit que c'est ambigu entre Prelude.+ et Tool.+ (Tool est le nom du module dans lequel sont définis mes types de donnée).

Je cherche donc un moyen de pallier à cette ambiguïté,

Merci d'avance,

AZ.

PS: Quel outil ZdS utilise-t-il pour la coloration syntaxique ? La "palette" des langages m'a l'air très étendue, en tout cas plus que celle d'OpenClassrooms

Vous avez raison additionner deux types différents c'est pas très naturel. Mais un autre opérateur aurait plus de sens. Cependant j'ai une autre question fortement liée. Dans une autre partie de mon programme (un générateur de labyrinthe), j'ai un type Maze qui représente un labyrinthe comme ceci:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

data MazeCell = MazeCell {
    position :: Position,
    filled   :: Bool,
    intact   :: Bool
}

data Maze = Maze {
    width  :: Int,
    height :: Int,
    cells  :: [[MazeCell]]
}

J'avais voulu surcharger l'opérateur !! pour obtenir l'objet MazeCell à une position donnée. Et bim, même problème… Pourtant ici l'opérateur a du sens, du coup y aurait-il une instance de laquelle on peut faire dériver Maze ? (Je ne comprend pas encore très bien type, class et instance, donc peut-être que ce que je dis n'a pas de sens )

Merci beaucoup pour vos réponses

Edit: peut être que katana a donné la bonne solution, je n'ai pas encore eu le temps de tester, je vois ça demain

D'accord merci beaucoup ce sujet est résolu. Il n'est pas impossible que je revienne (sur un autre thread) parce que Haskell et plus généralement le fonctionnel c'est très nouveau pour moi.

Mille mercis

Juste pour dire qu'en mathématiques, il est courant de définir l'opération $A + \vec{u}$ où $A$ est un point et $\vec{u}$ un vecteur, contrairement à $A + B$ qui n'a pas de sens. Mais en effet, en Haskell mieux vaut utiliser un autre symbole que + pour implémenter une telle opération.

Ouais ben les matheux utilisent autant de notations ambigües et non-standardisées qu'ils veulent, de toute façon personne ne les relit (et surtout pas un compilateur).