Comments on A Neighborhood of Infinity: Beyond Monads

mike,I still haven't got around to thinking for my...

2009-02-26T17:06:00.000-08:00

mike,

I still haven't got around to thinking for myself about what this construction is from a category theoretical perspective. End(C) was just a guess based on ordinary monads being monoids. I'll have to return to this when I have a moment.

sigfpe,In a normal monad, bind has type m a -> ( ...

2009-02-26T16:46:00.000-08:00

sigfpe,

In a normal monad, bind has type
m a -> ( a -> m b ) -> m b
where m:C -> C is a functor and a,b in C.

Your bind has type
( m s1 s2 ) a ->
( a -> (m s1 s2) b ) -> ( m s1 s2 ) b,
where
a,b in C,
s1, s2 in S,
and (ostensibly)
m(s1, s2):C -> C.

So you have a different functor from C to C for each pair (s1, s2) in S. However, you also forbid composition of such functors unless the types match, so the functors aren't really from C to C, they're from s1 x C to s2 x C.

This means you can't possibly be describing a category object in End(C). You have a 2-category whose objects are copies of C indexed by elements of S, functors between the categories, and natural morphisms between the functors.

It's a lovely construction, and well illustrated, just not the one you might have thought you were getting.

Better late than never :Phttp://groups.google.com/...

2009-02-24T03:23:00.000-08:00

Better late than never :P

http://groups.google.com/group/comp.lang.haskell/browse_thread/thread/98384971db91201e/44a51f58ebb6c6ad#44a51f58ebb6c6ad

mike,Haven't digested all of your comment yet. But...

2009-02-18T12:04:00.000-08:00

mike,

Haven't digested all of your comment yet. But briefly, a category object in End(C) is exactly what I'm thinking of. But I haven't expanded out the full definition myself to ensure all of the maps are exactly what they need to be.

A category object in Set consists of:- two sets O ...

2009-02-18T11:35:00.000-08:00

A category object in Set consists of:
- two sets O and M (objects and morphisms)
- a function i:O -> M (picks out the identity morphism)
- two functions s,t:M -> O (source and target)
- a function o:X -> M (composition), where X is a set equipped with two functions i,j:X -> M such that s o i = t o j (that is, it's the set of composable pairs and i,j pick out the first or second element)
such that the usual relations hold.

Category objects can be defined in any category with pairwise pullbacks:

A category object in C consists of
- two objects O, M
- a morphism i:O -> M
- two morphisms s, t:M -> O
- a morphism o:X -> M where X is equipped with two morphisms i,j:X -> M s.t. s o i = t o j
such that the usual relations hold.

The generalization you describe is as follows:

A "parametrized monad" consists of
- two sets O, M (where the elements of O are categories and the elements of M are functors between them)
- a function i:O -> M (picking out the identity functor on each category)
- two functions s,t:M -> O (source and target of the functors)
- a function o:X -> M (composition of functors)

But this is just a subcategory of Cat! What's going on? Just as a monoid is a one-object category, a monoidal category is a one-object 2-category. The generalization you describe moves from the monoidal category End(C) to a 2-category with more objects. So the real term you want isn't "parameterized monad", it's "sub-2-category of Cat".

A different generalization would be to consider a category object in End(C):

A category object in End(C) consists of
- two functors O, M
- a natural transformation i:O -> M
- two natural transformations s, t:M -> O
- a natural transformation o:X -> M where the functor X is equipped with two natural transformations i,j:X -> M s.t. s o i = t o j
such that the usual relations hold.

Can you come up with a use case for this one?

Ryan,I think "Indexed monad" and IxMonad are much ...

2009-02-17T17:50:00.000-08:00

Ryan,

I think "Indexed monad" and IxMonad are much better names. I'll check out Tov's session types paper.

Parametrized monads were also used in a Haskell Wo...

2009-02-17T17:31:00.000-08:00

Parametrized monads were also used in a Haskell Workshop 2008 paper with the name "class Monadish".

An implementation of the concept is available at http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Coroutine

I've been mucking about with functors between slic...

2009-02-15T11:22:00.000-08:00

I've been mucking about with functors between slice categories. Er, um,

type x :->: y = forall i. x i -> y i

class IFunctor (t :: (* -> *) -> * -> *) where
imap :: (x :->: y) -> (t x :->: t y)

To me this suggests.

class IMonad (t :: (* -> *) -> * -> *) where
iret :: x :->: t x
ibind :: (x :->: t y) -> (t x :->: t y)

Can we get back these domino-style parametrized monads?

Seems so.

data ILike :: * -> * -> * -> * where
ILike :: x -> ILike x i i

type Domino t i j x = t (ILike x j) i

dret :: IMonad t => x -> Domino t i i x
dret = iret . ILike

iTweak :: (x -> Domino t j k y) -> (ILike x j :->: t (ILike y k))
iTweak f (ILike x) = f x

dbind :: IMonad t => (x -> Domino t j k y) -> Domino t i j x -> Domino t i k y
dbind f b = ibind (iTweak f) b

Not sure where I'm going with this. Just thought I'd mention it. I detect traces of Dr Hancock...

augustss,It'd be easy to test to see what many of ...

2009-02-15T08:49:00.000-08:00

augustss,

It'd be easy to test to see what many of the consequences might be: try recompiling a non-trivial body of code with a parameterised monad library.

My main concern is with monad transformers. The types of the parameterised version will carry a lot of information. We could start getting some pretty big signatures.

Augustss: My experience has been both. Sometim...

2009-02-15T08:26:00.000-08:00

Augustss: My experience has been both. Sometimes you do get impenetrable error messages; often because some definition you got wrong a page or two of code ago actually does typecheck, whereas it wouldn't have previously.

I quickly learned to frequently use ghci to infer the most general type of new definitions. If the type appeared to be right, I'd copy and paste it into my code, if it was obviously wrong, I'd try again. When problems arose, sometimes it took a fair bit of mental effort to figure out exactly what they were.

There is definitely higher type overhead, at least in the short run. But it puts the type system to better work _for you_, among other compelling advantages.

GHC supports do-notation for parameterized monads ...

2009-02-15T05:58:00.000-08:00

GHC supports do-notation for parameterized monads just fine, as it turns out.

I tried to write some code here to show you how to do it but Blogger doesn't allow me to use the proper tags when commenting so it will just look like crap. Instead here is a link to my blog which shows how to do it.

GHC does support do-notation for parameterised mon...

2009-02-15T05:27:00.000-08:00

GHC does support do-notation for parameterised monads. With GHC 6.10 (at least) you merely need to use {-# LANGUAGE NoImplicitPrelude #-}
and GHC will resolve do-notation to use whatever is in scope for (>>=), (>>) and "return". Parameterised monads are also used in Oleg et al's lightweight static resources paper.

"At the very least, do-notation needs to be adapte...

2009-02-15T05:20:00.000-08:00

"At the very least, do-notation needs to be adapted to support ParameterisedMonad. "

This is already possible in Ghc using -XNoImplicitPrelude or the corresponding LANGUAGE pragma.

---

Just for fun, let me try to continue with your idea. Instead of taking (>>=) as a primitive, I prefer fmap, join and Applicative stuff. So:

> class ParameterisedFunctor m where
> fmap :: (a -> b) -> (m s s a) -> (m s s b)
>
> class ParameterisedFunctor m => ParameterisedPointed m where
> pure :: a -> m s s a
>
> class ParameterisedPointed m => ParameterisedApplicative m where
> (<*>) :: m s1 s2 (a -> b) -> m s2 s3 a -> m s1 s3 b
>
> class ParameterisedApplicative m => ParameterisedMonad m where
> join :: m s1 s2 (m s2 s3 a) -> m s1 s3 a

Now take the ParameterisedApplicative class. For normal Applicatives there is a Dual instance that reverses the order of effects, i.e.:

> (<**>) :: m a -> m (a -> b) -> m b

Here the reversed ordering is not clear from the type. However, with ParameterizedApplicative:

> (<**>) :: m s1 s2 a -> m s2 s3 (a -> b) -> m s1 s3 b

We do see the ordering of effects in the type.

---

Also, the type "m s1 s2 a" reminds me a lot of the types of Control.Category. Is there something equivalent to the Kleisli wrapper?

> newtype Kleisli m a b = Kleisli
(a -> m b)

MIND = BLOWNThis is awesome stuff!

2009-02-15T03:51:00.000-08:00

MIND = BLOWN

This is awesome stuff!

Just to note that some Haskell programmers were us...

2009-02-15T03:45:00.000-08:00

Just to note that some Haskell programmers were using this extended notion of ParametrisedMonad even before the do-notation was standardised. For instance, back in 1994-5, Niklas Röjemo used this idiom extensively inside the nhc12 and nhc13 compilers. See here for evidence.

I agree. I always wanted monads to be more flexibl...

2009-02-15T03:36:00.000-08:00

I agree. I always wanted monads to be more flexible, but as not so experienced Haskell programmer I thought it is something wrong with me since hackers of Haskell would have seen it a long time ago, wouldn't they? I feel relieved (a little bit ^^). Thank you sigfpe!

Dan, have you tried to use do-notation with this d...

2009-02-15T03:17:00.000-08:00

Dan, have you tried to use do-notation with this definition of Parameterised Monads ? If so, what was the problem? Since GHC supports rebindable syntax, do-notation should just work when throwing in a NoImplicitPrelude pragma.

This is related to a (wilder) notion of parameterised monads that Edward Kmett gave some time ago.

ParametrizedMonad is indeed a very useful abstract...

2009-02-15T02:52:00.000-08:00

ParametrizedMonad is indeed a very useful abstraction. But it makes me wonder what happens to type inference and to error messages. I just don't know the answer.

Can the extra flexibility cause ambiguities?

What happens when one makes an error? Might it still type check? Or give an even stranger type error?

To get do-notation, can't you just use NoImplicitP...

2009-02-15T01:55:00.000-08:00

To get do-notation, can't you just use NoImplicitPrelude?

So shouldn't they be called arrowads instead since...

2009-02-15T00:27:00.000-08:00

So shouldn't they be called arrowads instead since they are no longer abstract monoids?

Here lies a dependently typed version: http://www....

2009-02-15T00:13:00.001-08:00

Here lies a dependently typed version: http://www.cs.nott.ac.uk/~nad/repos/lib/Category/Monad/Indexed.agda

Here lies a dependently typed version: http://www....

2009-02-15T00:11:00.000-08:00

Here lies a dependently typed version: http://www.cs.nott.ac.uk/~nad/repos/lib/Category/Monad/Indexed.agda

Nice observation. Certainly, one major reason w...

2009-02-14T22:59:00.000-08:00

Nice observation. Certainly, one major reason why parameterized monads are so attractive is exactly because of the easy upgrade path. Anybody who is comfortable writing monadic code can get started very easily, and allow the typechecker to do the heavy mental lifting for them.