Déterminer l'équivalent d'une comonade en arrow

Salut,

Je suis en train d'écrire une librairie d'arrow transformers qui porte pour l'instant majoritairement des monades de mtl en arrows.

Pour donner un exemple: la monade StateT de mtl

1

newtype StateT s m a = StateT { runStateT :: s -> m (a, s) }

… devient dans ma librairie une arrow:

1

newtype StateTA s a b c = StateTA { runStateTA :: a (b, s) (c, s) }

Donc pour la plupart des monades je n'ai pas eu de mal, mais maintenant je voudrais essayer de porter des comonades du package comonad en arrow.

J'ai vraiment du mal à transformer par exemple la définition de StoreT en arrow.

J'ai demandé sur freenode #haskell ce qu'ils en pensaient, mais j'ai pas eu de réponse, si ce n'est , d'utiliser une arrow Cokleisli sur StoreT mais pour cela il me faudrait déjà un équivalent en arrow de ComonadStore, mais là aussi je bloque, surtout pour seek.

Vous avez une idée ?

Merci d'avance,

felko

T'es sûr que Cokleisli Store est équivalente à l'arrow que je recherche ?

Pour simplifier le problème avec un truc qu'on connaît, est-ce que que Kleisli State est équivalente à StateTA (->) ?

Et par rapport à ce que j'ai dit, en fait pour pouvoir utiliser Cokleisli Store comme je veux, c'est à dire avec les fonctions pos, peek, etc…, il faudrait l'instancier pour ma classe ArrowStore (analogue à ComonadStore du package comonad mais pour les arrows). Et le souci c'est que j'arrive pas non plus à porter toutes les fonctions de cette classe en arrows.

En fait je pense que je comprend pas assez bien les comonades, tu aurais des ressources qui expliquent ce concept ? J'ai lu les papiers de Dominic Orchard mais ça reste assez abstrait donc j'aurais besoin d'un cas concret pour saisir dans son ensemble la notion de comonade.

C'est bon, je pense avoir trouvé, en tout cas mon type est une instance de Category et de Arrow, donc je pense que c'est bon:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

newtype StoreT s a b c = StoreT { runStoreT :: a (s -> b, s) c }

instance Arrow a => Category (StoreT s a) where
    id = StoreT (arr $ uncurry ($))
    StoreT a . StoreT b = StoreT $ proc (f, s) -> do
        x <- b -< (f, s)
        a -< (const x, s)

instance Arrow a => Arrow (StoreT s a) where
    arr = (id >>^)
    first (StoreT a) = StoreT $ proc (f, s) -> do
        (x, y) <- returnA -< f s
        x' <- a -< (const x, s)
        returnA -< (x', y)