On Sat, Aug 20, 2011 at 6:26 PM, Tom Schouten wrote:

data Kl i o = forall s. Kl s (i ->  s ->  (s, o))

This is an Arrow.  At first I wondered if there was also an associated Monad, hence the iso function.

Given data Kl i o = forall s. Kl s (i ->  s ->  (s, o)) instance ArrrowApply KI where ... then 'ArrowMonad KI' [1] is a monad isomorphic to data KIM o = forall s. KIM s (s -> (s, o)) Is this what you are looking for? Cheers! =) [1] http://hackage.haskell.org/packages/archive/base/4.3.1.0/doc/html/Control-Ar... -- Felipe.

(Code from this e-mail attached.) On Sun, Aug 21, 2011 at 7:22 AM, Tom Schouten wrote:

Yes, but I run into the same problem.

data Kl i o = forall s. Kl (i -> s -> (s, o))

You actually forgot the 's' field of KI in my e-mail. If you define data KI i o = forall s. KI s (i -> s -> (s, o)) instance Category KI where ... instance Arrow KI where ... You can make instance ArrowApply KI where app = KI () $ \(KI s u, b) _ -> ((), snd $ u b s) But this is probably very uninteresting, since the state is just thrown away. However, if you used data KIT i o = forall s. Typeable s => KIT s (i -> s -> (s, o)) instance Category KIT where ... instance Arrow KIT where ... You could make instance ArrowApply KIT where app = KIT (toDyn ()) $ \(KIT s u, b) dyn -> first toDyn $ u b (fromDyn dyn s) This app operator behaves as KI's app when the argument is not very well behaving (i.e. changing the state type). However, when the argument does behave well, it is given the associated state only once. All further iterations work as they should. Note that since ArrowApply is equivalent to Monad, you may also try going the other way around. That is, define data KIM o = forall s. KIM s (s -> (s, o)) instance Monad KIM where return x = KIM () $ \_ -> ((), x) KIM sx ux >>= f = KIM sx u where u sx' = let (tx, i) = ux sx' in case f i of KIM sf uf -> let (_, o) = uf sf in (tx, o) I haven't checked, but I think that 'Kleisli KIM' is isomorphic to 'KI', and that 'ArrowMonad KI' is isomorphic to 'KIM'. You may also define data KIMT o = forall s. Typeable s => KIMT s (s -> (s, o)) instance Monad KIMT where return x = KIMT () $ \_ -> ((), x) KIMT sx ux >>= f = KIMT (sx, toDyn ()) u where u (sx', dyn) = let (tx, i) = ux sx' in case f i of KIMT sf uf -> let (tf, o) = uf (fromDyn dyn sf) in ((tx, toDyn tf), o) And the same conjecture applies between 'Kleisli KIMT' and 'KIT', and between 'KIMT' and 'ArrowMonad KIT'. Conclusion: Data.Typeable lets you cheat =). Cheers, -- Felipe.

Ehm... what? How can you do such a replacement without losing, for example, functions like this: f (KI s h) i = snd $ h i $ fst $ h i s Отправлено с iPad 24.08.2011, в 11:43, oleg@okmij.org написал(а):

...

I had simplified the type to make the plumbing simpler. My intention was to include an initial value to use the function as a sequence transformer / generator:

data Kl i o = forall s. Kl s (i -> s -> (s, o))

That change makes a world of difference! For example, the above type (Kl i) is clearly a monad

...

instance Monad (Kl i) where return x = Kl () (\_ s -> (s,x)) (Kl s m) >>= f = Kl s (\i s -> case f (snd (m i s)) of Kl s' m' -> (s,snd (m' i s')))

It is the Reader monad. Different Kl values have their own, private s. The quantification ensures that each encapsulated 's' applies only to its generator. Therefore, we can just as well apply that 's' right at the very beginning. Therefore,

...

data Kl i o = forall s. Kl s (i -> s -> (s, o))

is essentially

...

data Kl' i o = Kl' (i -> o)

which is certainly and Arrow and a Monad. We do not need existential at all. The web page http://okmij.org/ftp/Computation/Existentials.html describes other eliminations of Existentials.

...

Does the "growing type" s1 -> s2 -> (s1,s2) in the bind-like method below support some other abstraction that is monad-like?

data Kl1' s o = Kl1' (s -> (s,o))

bind' :: (Kl1' s1 i) -> (i -> Kl1' s2 o) -> (Kl1' (s1,s2) o)

bind' mi f = Kl1' mo where mo (s1,s2) = ((s1',s2'),o) where (Kl1' u1) = mi (s1', i) = u1 s1 (Kl1' u2) = f i (s2', o) = u2 s2

Not all things are monads; for example, restricted and parameterized monads are not monads (but do look like them, enough for the do-notation). Your Kl1' does look like another generalization of monads. I must say that it seems to me more fitting for a parametrized applicative:

...

class Appish i where purish :: a -> i s a appish :: i s1 (a ->b) -> i s2 a -> i (s1,s2) b

data KL s a = KL (s -> (s,a))

instance Appish KL where purish x = KL (\s -> (s,x)) appish (KL f1) (KL f2) = KL $ \(s1,s2) -> let (s1', ab) = f1 s1 (s2', a) = f2 s2 in ((s1',s2'), ab a)

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe