class MonadPlus m => MonadRing m

[Tim Sweeney]

class MonadPlus m => MonadRing m where
    mone :: m a
    ** :: m a -> m a -> m a

Does anybody have experience with a construct like MonadRing above?  I'm
interested in prior implementations, examples of instances, and coherence
rules.

A conceptual example: consider ListMonad, used to implement
"non-determinism", or computations that may produce multiple values.  In
this context, the order or duplication of elements in a list is not
significant; we think of them as sets of values:

>From Functor:
    fmap f xs -- apply a function to all elements in the set, and collect
the results in a set

>From Monad:
    xs>>=f -- apply a set-returning function to all elements of x, and merge
all the results into a set
    return xs -- generate a singleton set containing only x

>From MonadPlus:
    mzero -- the empty set
    xs++ys -- the union of sets xs and ys

>From MonadRing:
    xs ** ys -- the intersection of the sets xs and ys.
    mone -- the unit of **. conceptually, "the set of all sets". With
Haskell's type system, this notion isn't feasible with ListMonad directly,
but could be used with similar "set-like" monads containing elements drawn
from a finite set.

For set-like monads, there is then a further notion of a partial order
relation defined by set inclusion.  This could be defined along the lines of
"mcontains :: m a -> m b -> m bool".  For ListMonad, mcontains xs ys can be
defined as true iff xs contains all elements of ys, in order, allowing
arbitrary new elements that happen to occur between them.

I'm not sure of the practical utility of these constructs in the Haskell
world, but I've been working with them for a while in an experimental
language and have found them very powerful, especially when coupled with
first-class types with set-like functionality a la David McAllester "Ontic"
language.  In my particular case, I have found the following syntactic sugar
to aid a great deal in the readability of complex monad expressions:

    -- Non-monad constructs:

    f(x) -- call function f with parameter x
    let x=v in e -- let-binding.

    -- Functor syntactic sugar:

    f($x) -- like map f x
    let x$=v in e -- like map (\x -> e) x

    -- Monad syntactic sugar:

    f(%x) -- like x >>= f
    let x%=v in e -- like v >>= \x -> e

This could be considered a syntactic alternative to the "do" notation and
list comprehension notation.

-Tim Sweeney