Re: [Haskell-fr] Re: inférence

[Dupont Corentin]

Merci Beaucoup ça m'éclaire bien!
Je ne suis pas encore très à l'aise avec ces histoires de classes de
types, c'est une généralisation qu'on ne voit pas trop dans les autres
languages ;)

Si j'ai bien compris, les types sont regroupés en classe en fonction
de leurs propriétés.
Eq pour les types qui supportent l'égalité (quel type ne supporte pas
l'égalité??)
Ord pour les types qu'on peut trier etc.
Certains types appartiennent à plusieurs classes donc?


OK, le ' n'est pas un opérateur
mais la virgule , oui! magnifique

Il faudra que je regarde cette classe Arrow, elle m'intrigue...

Merci encore
Je relirais ton message plusieurs fois pour bien imprimer tout ça ;)

Corentin


On 9/13/07, Eric Kow <eric.kow at gmail.com> wrote:
> On 13/09/2007, Dupont Corentin <corentin.dupont at gmail.com> wrote:
> > Personne ne peut me répondre sur mon erreur ci-dessous?
> > comment caster de Float en Double?
>
> je ne sais pas... peut-être realToFrac pour faire une conversion?
> l'hierarchie des classes dans
>  http://en.wikibooks.org/wiki/Haskell/Class_declarations
> pourrait être pertinent
>
> sinon, tu peux aussi changer tes fonctions pour qu'elles acceptent
> Double, ou les généraliser:
>  blend_un_point :: Float -> (Integer -> Float) -> Integer -> Float
> deviendra
>  blend_un_point :: (Fractional a) => (Integer -> a) -> Integer -> a
>
> J'ignore la difference entre Fractional, Floating, etc
>
> > J'ai d'autres questions:
> > Je n'ai pas très bien compris ce que signifie le '.
>
> où? de temps en temps, on utilise x' ou foo' comme nom de variable.
> j'aime pas trop parce que je trouve le « ' » pas très visible, mais
> d'autres programmeurs ont l'air d'apprecier
>
> > Je ne comprend pas très bien ce que font des opérateurs comme &&&:
>
> j'utilise les dessins dans
>  http://en.wikibooks.org/wiki/Haskell/Understanding_arrows
> pour ça
>
> une utilisation de (&&&) de simplifier (f x, g x) en (f &&& g) x
>
> par abus de typage, on pourrait dire que
> (&&&) :: (b -> c) -> (b -> c') -> (b -> (c, c'))
> c'est à dire que (&&&) peut prend deux fonctions f et g; et un
> paramètre x, il appliquera f et g à x, et renovera le résultat dans un
> tuple.
>
> mais en fait, c'est en plus géneral que ça
>
> > (&&&) :: (Arrow a) => a b c -> a b c' -> a b (c, c')
> > Dans la signature, que signifient les espaces entre les a,b,c...?
>
> Je sais pas comment ça s'appelle, mais tu as peut-être vu que il exist
> des types qui prennent des paramètres.  Par exemple Maybe prend un
> variable a; donc si je donne Int au type Maybe, j'aurai le type Maybe
> Int.  Either est un autre exemple, il prend deux parametrès.  Ainsi,
> Either Int Float  est un type.  Par fois on écrit des fonctions qui
> marche avec des variables de types.  Par exemple, la fonction
>  fromMaybe :: a -> Maybe a -> a
> marche pour tous les paramètres qu'on peut donner au type Maybe
>
> Dans Haskell, tu peux écrire qqc encore plus general.  Comparons
>
>  fromMaybe :: a -> Maybe a -> a
>  fromBlah :: (Blah x) => a -> x a -> a
>
> fromBlah marche pas seulement avec Maybe, mais avec tous les types «x»
> qui sont des instances de la class Blah.  De façon similaire,
>  (&&&) :: a b c -> a b c' -> a b (c,c')
> (&&&) marche pour les types «a» qui sont des instances d'Arrow, pas
> que pour les fonctions ((->) est un instance de Arrow parmi d'autres)
>
> On peut voir que la signature abusive que j'ai donné est similaire à
> la signature ci-dessus en la réecrivant:
>
> (&&&) :: (b -> c) -> (b -> c') -> (b -> (c, c'))
> (&&&) :: ((->) b c) -> ((->) b c') -> ((->) b (c, c'))
> (&&&) :: ((a) b c) -> ((a) b c') -> ((a) b (c,c')) -- je remplace « ->
> » par « a »
> (&&&) :: (a b c) -> (a b c') -> (a b (c,c'))
> (&&&) :: a b c -> a b c' -> a b (c,c')
>
> Si ça fait un peu bizzare de remplacer « -> » par « a », c'est utile
> de se rappeller que les types commes « , » sont des types comme des
> autres.  C'est juste que là on utilise un opérateur pour le nom du
> type (comme on utilise (+) au lieu d'une fonction plus)
>
> Donc on pourrait imaginer...
>
>  fst :: (x,y) -> x
>  fst :: ((,) x y) -> x
>  fstFoo :: (Foo a) => a x y -> x
>
> Ne fait pas trop confiance à mes propos; je suis loin d'être expert,
> et j'ai peut-être dit des bêtisses, ou utilisé des abus de langage
> sans savoir.
>
> --
> Eric Kow                     http://www.loria.fr/~kow
> PGP Key ID: 08AC04F9         Merci de corriger mon français.
>
> _______________________________________________
> Haskell-fr mailing list
> Haskell-fr at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-fr
>
>