Lambda the Ultimate

this is a translation of the sheep example in the monad tutorial to c++.
features a poor try to use c++ template spezialization as substitute for type-classes ...

hope this qualifies ;)

Don't forget Oleg's Monadic Programming in Scheme.

Monads in C++

Scala implementation of a simple interpreter using monads.

Don't know if this has anything to do with monads but looks interesting. (I confess, all I did was google "monad").

Windows Monad Shell

dimitre novatchev has a monad in xslt - not released yet

I thought i'd add a miranda implementation to the discussion. The transliteration is not a 100% percent exact, in that the ADT "maybe" is acessible to the rest of the program and because of that can always inspect the innards of the maybemonad. This hiding can be achieved by placing a '%export maybeMonad' compiler directive at the top of the script. This hides all definitions except those explicitly exported but obfuscates the main point which is the monad type. This discussion is a good companion to the implementation (as I used it as a base).

See
here for a overview of Turner's miranda language.

abstype
  maybeMonad *
with  
  || make an instance of the monad container 
  return     :: * -> maybeMonad *  
  || 'flatten' some unneeded layers of packing (just needed in bind?)
  join       :: maybeMonad (maybeMonad *) -> maybeMonad *
  || apply some operation on the secret value of the monadic container 
  mapfunctor :: (* -> **) -> (maybeMonad *) -> (maybeMonad **)
  || apply some operation on monads, on this monad's value 
  bind       :: (maybeMonad *) -> (* -> (maybeMonad **)) -> (maybeMonad **)
      
maybe *      ::= Just *
               | Nothing

maybeMonad * == maybe *

|| return 'Just' a :)
return a = (Just a)

|| flatten a nesting of maybe's (N.B. typing ensures a = (Just b))
join (Just a) = a

|| apply an functor to our value
mapfunctor f (Just a)  = Just (f a)
mapfunctor f (Nothing) = Nothing

|| combine the this computation with another
bind a f = join (mapfunctor f a)

An example use is as follows:

foo n = return (10*n)

main  = bind (return 1) foo

which reduces to: (Just 10)

ps. Many thanks to Ehud for keeping this site running, I really enjoy it!

(Stumbled over this when browsing old #haskell irc logs)
Monadic parsing in Tcl
Maybe and Error

Serially-numbering monad in Slate (Slate downloads)

Take a look at this. (And the LINQ is a well designed Monadic environment too.)