Question sur Data.fromList [Résolu]

[james-mi]

il y a qqch que je n'arrive pas à comprendre dans Data.Map :

1.

Code :

1
2
3
ghci > fromList [(1 ,2) ,(3 ,4) ,(3 ,2) ,(5 ,5)]
fromList [(1,2),(3,2),(5,5)]
it :: Map Integer Integer

pourquoi la valeur renvoyée est-elle "fromList ..." alors que fromList, de toute évidence, n'est pas un constructeur (pour qui la majusculle initiale est obligatoire).
cela renvoie une valeur sous la forme d'une fonction ? ? ?

2. D'autre part ,

Code :

1
2
ghci > :t fromList
fromList :: (Ord k) => [(k, a)] -> Map k a

ok, jusque là ça va ...
puis :

Code :

1
2
let myFromList = fromList
myFromList :: [((), a)] -> Map () a

On sent bien qu'on ne va pas aller loin avec un Map ()
effectivement :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
ghci> myFromList [(1 ,2) ,(3 ,4) ,(3 ,2) ,(5 ,5)]


<interactive>:1:37:
    No instance for (Num ())
      arising from the literal `5' at <interactive>:1:37
    Possible fix: add an instance declaration for (Num ())
    In the expression: 5
    In the expression: (5, 5)
    In the first argument of `myFromList', namely
        `[(1, 2), (3, 4), (3, 2), (5, 5)]'

Pourquoi ne peut-on pas créer myFromList de cette manière ?

merci d'avance à ceux qui pourront m'expliquer ...

[viro]

Envoyé par james-mi

il y a qqch que je n'arrive pas à comprendre dans Data.Map :

1.

Code :

pourquoi la valeur renvoyée est-elle "fromList ..." alors que fromList, de toute évidence, n'est pas un constructeur (pour qui la majusculle initiale est obligatoire).
cela renvoie une valeur sous la forme d'une fonction ? ? ?

Ce que tu vois n'est pas la valeur renvoyée, c'est sa traduction sous forme de chaine de caractères.
sous ghci, fromList [(1,etc...] devient l'équivalent de
print $ fromList ...
qui lui même est
putStrLn $ show $ fromList ....

Ensuite se pose la question : comment représenter une Map ? on peut imaginer plusieurs façons, mais les auteurs de Data.Map on retenu celle qui consiste a imprimer "fromList " puis la conversion de la map en liste.

Ce qui est marrant c'est que quand tu tapes le fromList [etc...] ghci convertit la liste en Map, puis pour afficher le résultat fait aussitôt le travail inverse.

Il n'y a pas à s'inquiéter de ca, en pratique on n'affiche pas une Map, on s'en sert pour faire des recherches.

Envoyé par james-mi

2. D'autre part ,

Code :

ok, jusque là ça va ...
puis :

Code :

On sent bien qu'on ne va pas aller loin avec un Map ()
effectivement :

Code :

Pourquoi ne peut-on pas créer myFromList de cette manière ?

A cause de la restriction de monomorphisme, ghc(i) ne peux pas inférer un type polymorphique pour myFromList.
En pratique dans un vrai programme, ghc dispose de suffisamment d'informations de contexte pour trouver un type précis pour une fonction du genre de myFromList, donc ca pose rarement un problème.

Deux façons de contourner:

1) définir myFromList comme suit :

let myFromList l = fromList l

2) virer la restriction de monomorphisme:

:set -XNoMonomorphismRestriction
let myFromList = fromList

A propos de cette restriction, j'aurais du mal à expliquer la raison, mais elle est tellement débatue qu'une recherche de monomorphisme sur google devrait donner des réponses. En anglais , par contre.

[james-mi]

Envoyé par viro

Ce que tu vois n'est pas la valeur renvoyée, c'est sa traduction sous forme de chaine de caractères.
sous ghci, fromList [(1,etc...] devient l'équivalent de
print $ fromList ...
qui lui même est
putStrLn $ show $ fromList ....

Ensuite se pose la question : comment représenter une Map ? on peut imaginer plusieurs façons, mais les auteurs de Data.Map on retenu celle qui consiste a imprimer "fromList " puis la conversion de la map en liste.

Ce qui est marrant c'est que quand tu tapes le fromList [etc...] ghci convertit la liste en Map, puis pour afficher le résultat fait aussitôt le travail inverse.

Il n'y a pas à s'inquiéter de ca, en pratique on n'affiche pas une Map, on s'en sert pour faire des recherches.



A cause de la restriction de monomorphisme, ghc(i) ne peux pas inférer un type polymorphique pour myFromList.
En pratique dans un vrai programme, ghc dispose de suffisamment d'informations de contexte pour trouver un type précis pour une fonction du genre de myFromList, donc ca pose rarement un problème.

Deux façons de contourner:

1) définir myFromList comme suit :

let myFromList l = fromList l

2) virer la restriction de monomorphisme:

:set -XNoMonomorphismRestriction
let myFromList = fromList

A propos de cette restriction, j'aurais du mal à expliquer la raison, mais elle est tellement débatue qu'une recherche de monomorphisme sur google devrait donner des réponses. En anglais , par contre.

OK, merci.

Donc quand je construit mes fonctions plus compexes, et que je les évalues dans GHCi (parce que ça aide bien quand on est un peu perdu) et que ça me renvoie "fromList [(,.....),...], je sais qu'en réalité j'ai affaire à une structure Map, c'est bien ça ?

[viro]

Envoyé par james-mi

OK, merci.

Donc quand je construit mes fonctions plus compexes, et que je les évalues dans GHCi (parce que ça aide bien quand on est un peu perdu) et que ça me renvoie "fromList [(,.....),...], je sais qu'en réalité j'ai affaire à une structure Map, c'est bien ça ?

Pas forcément. Rien n'empêche qu'un autre type de donnée définisse sa méthode show par "fromList [... ]"
Après tout, ce n'est que du texte.
Donc pour en être sûr, il te faut interroger le type de ton expression; en tapant sous ghci :t mon_expression_complexe.

P.S, précision supplémentaire au sujet du problème:

Code :

1
2
let myFromList = fromList
-- myFromList :: [((), a)] -> Map () a

quand tu le compile, ghc te refuse avec le message suivant

Code :

1
2
3
4
5
6
    Ambiguous type variable `k' in the constraint:
      `Ord k' arising from a use of `fromList' at tt.hs:6:13-20
    Possible cause: the monomorphism restriction applied to the following:
      myFromList :: forall a. [(k, a)] -> Map k a (bound at tt.hs:6:0)
    Probable fix: give these definition(s) an explicit type signature
                  or use -XNoMonomorphismRestriction

Or, il te l'a accepté sous ghci, mais avec une signature bizarre. Ce qui se passe, c'est que sous ghci, il y a des règles qui font qu'un type par défaut est sélectionné quand il y a ambiguité. Dans ce cas, le type par défaut est () donc Map k a devient Map () a.

Ce sont ces règles de "type par défaut" qui sont responsables sous ghci du résultat suivant:

Code :

1
2
3
4
5
6
Prelude> :t (+)
(+) :: (Num a) => a -> a -> a
Prelude> let p=(+)
Prelude> :t p
p :: Integer -> Integer -> Integer
Prelude>

Donc Integer est le type par défaut dans ghci retenu quand il y a contrainte sur la classe Num.

Code :

1
2
3
4
5
6
7
Prelude> import Data.List
Prelude Data.List> :t sort
sort :: (Ord a) => [a] -> [a]
Prelude Data.List> let s=sort
Prelude Data.List> :t s
s :: [()] -> [()]
Prelude Data.List>

Donc () est le type par défaut retenu dans ghci quand il y a contrainte sur la classe Ord.

Code :

1
2
3
4
5
6
7
Prelude Data.List> :t show
show :: (Show a) => a -> String
Prelude Data.List>                                                                                                                                                    
Prelude Data.List> let h=show                                                                                                                                         
Prelude Data.List> :t h                                                                                                                                               
h :: () -> String                                                                                                                                                     
Prelude Data.List>

Donc () est le type par défaut retenu dans ghci quand il y a contrainte sur la classe Show.

etc, etc, etc.

[james-mi]

Envoyé par viro

...

OK merci viro, ça m'éclaircit bien les idées