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

[Eric Kow]

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.