exemple Applicative pour l'Etat - pour des flux de données

Question

Je suis en train de mettre en œuvre par exemple Applicative pour un tel type:

newtype State s a = State {runState :: s -> (a, s)} 

J'ai quelques idées différentes pour (< *>) fonction. Une façon de mettre en œuvre qui me vient à l'esprit est

(<*>) :: State s (a -> b) -> State s a -> State s b 
State f <*> State s = State $ do 
    (fa, fs) <- f 
    let (sa, ss) = s fs 
    return (fa sa, ss) 

Ou

(<*>) :: State s (a -> b) -> State s a -> State s b 
State f <*> State s = State $ do 
    (sa, ss) <- s 
    let (fa, fs) = f ss 
    return (fa sa, fs) 

Lequel (ou fait même l'un d'eux) est correcte et pourquoi?

Ils sont tous les deux typecheck et ne diffèrent que par l'ordre des transformations "state". Je ne trouve pas de bonne raison de préférer l'un à l'autre ...

Answer 1

Je crois que les deux sont corrects, car ils ne violent pas les lois d'application autant que je peux voir. Cependant, le premier est ce qui est réellement utilisé. Je pense que c'est à cause de la convention: on s'attend à ce que les effets des arguments de gauche de <*> s'appliquent d'abord, avant son argument de droite. Comparer avec IO, par exemple, où

(,) <$> readLn <*> getLine :: IO (Int, String) 

invites pour le premier Int, puis lit une chaîne. C'est agréable de voir l'État se comporter de la même manière.

Answer 2

Les deux sont raisonnables. Notez que vous pouvez obtenir l'un d'eux de l'autre:

x <*2> y = flip ($) <$> y <*1> x 

Il est une convention de bibliothèque, cependant, que les « effets » sont effectués de gauche à droite. Par conséquent, la première version semble plus familier.

Answer 3

Tout d'abord, je vous recommande de ne pas utiliser la syntaxe (monadique!) do pour définir une instance applicative comme ça, car elle obscurcit plutôt ce qui se passe. Voici vos définitions en utilisant uniquement la syntaxe fonctionnelle standard:

State f <*> State s = State $ \q 
    -> let (fa, fs) = f q 
      (sa, ss) = s fs 
     in (fa sa, ss) 

et

State f <*> State s = State $ \q 
    -> let (fa, fs) = f ss 
      (sa, ss) = s q 
     in (fa sa, fs) 

Cela rend également plus clair qu'il n'y a pas vraiment de l'ordre d'évaluation intrinsèque dans une instance applicative (contrairement à une instance monade).