Haskell Applicative Functor en F #

Question

En Haskell nous pouvons écrire le code comme ceci:

Comment faire même chose en F #?

J'essaie écrire quelque chose comme code, mais ce n'est pas même

let (<*>) f v = 
    match v with 
    | Some v' -> 
     match f with 
     | Some f' -> Some (f' v') 
     | _ -> None 
    | _ -> None 
let cnst a _ = a 
let id = cnst <*> cnst // but it seems impossible 
let id' x = (Some (cnst x)) <*> (Some(cnst x x)) // it works 

Mais dans Haskell id::b->b, en fa # id:'a->'a Option

Ce que je fais mal? Comment atteindre le même résultat? PS: Comme je le sais avec un applicatif, nos valeurs sont enveloppées dans un contexte, tout comme les fonctions et les fonctions sont également intégrées dans un contexte!

Some((+)3) and Some(2) 

Dans ce contexte de cas est l'option

Et méthode Applay est comme ceci:

let Apply funInContext valInContext = 
    match funInContext with // unwrap function 
    | Some f -> 
     match valInContext with // unwrap value 
     | Some v -> Some(f v) // applay function on value and wrap it 
     | _ -> None 
    | _ -> None 

Answer 1

Je suis un peu confus par ce que votre code tente d'atteindre, car il a le type

(a -> Maybe b) -> Maybe a -> Maybe b 

Ceci est le type de liaison pour la structure monad habituellement imbue Maybe/option avec mais cela n'a pas de sens si vous essayez de travailler avec l'instance applicative pour les fonctions que nous avons dans Haskell. Il y a deux choses que nous devons changer alors, la première est que nous devons travailler avec les fonctions et les applicatifs afin que le code atteigne l'effet désiré. Cela devrait avoir le type

(a -> (b -> c)) -> (a -> b) -> (a -> c) 

On peut donc écrire ce que

let (<*>) f x a = (f a) (x a) 

Maintenant, si nous faisons un pas l'exemple d'origine

(cnst <*> cnst) a = (cnst a) (cnst a) 
        = a 

donc nous avons en effet que cnst <*> cnst = id selon les besoins.