Nice, but needs more steps... get me to the point where I understand what a Monad is, because I really want to know!
Lets define a simple type, `Maybe', which can store either a value or an absence of value:
data Maybe a = Just a | Nothing
deriving (Show)
clamp :: Ord a => a -> a -> Maybe a
clamp limit x = if x > limit then Nothing else Just x
One way is to just brute-force it:
multiclamp :: Ord a => a -> a -> a -> Maybe a
multiclamp lim1 lim2 x = case clamp lim1 x of
Nothing -> Nothing
Just x' -> clamp lim2 x'
First, take a look at the core Monad operations. I'm going to use `build' and `bind' instead of `return' and `>>=', because they're probably more familiar to most readers.
class Monad m where
build :: a -> m a
bind :: m a -> (a -> m b) -> m b
instance Monad Maybe where
build x = Just x
bind Nothing _ = Nothing
bind (Just x) f = f x
multiclamp2 :: Ord a => a -> a -> a -> Maybe a
multiclamp2 lim1 lim2 x = bind
(clamp lim1 x)
(\x' -> clamp lim2 x')
multiclamp3 :: Ord a => a -> a -> a -> Maybe a
multiclamp3 lim1 lim2 x =
(clamp lim1 x) >>=
(\x' -> clamp lim2 x')
multiclamp4 :: Ord a => a -> a -> a -> Maybe a
multiclamp4 lim1 lim2 x = do
x' <- clamp lim1 x
clamp lim2 x'
For completeness, here's a "cleaner" version, which takes advantage of currying and the combinator `.':
multiclamp5 :: Ord a => a -> a -> a -> Maybe a
multiclamp5 lim1 lim2 = (clamp lim2 =<<) . clamp lim1 is the purpose of the Maybe monad to abstract the concept of "evaluate to Nothing if the previous expression evaluated to nothing?
Also, is 'build'/'return' being used implicity somewhere?
In real code, it's mostly used when the exact monad being used isn't specified. For example, here's a function which runs a monadic computation until it returns `False'. The result is `()', sort of a Haskell void type.
runUntil :: Monad m => m Bool -> m ()
runUntil comp = loop where loop = do
x <- comp
if x then loop else return ()
C# and Python can, sort of, but their syntax and object-oriented semantics make it somewhat difficult. I don't know C# well, and Python needs a lot of magic[1] to get reasonable-looking code.
Here's a Python example. It's not a direct translation, but is close enough that you should be able to figure out the original. I've included the Haskell code in comments.
import abc
# class Monad m where
# build :: a -> m a
# bind :: m a -> (a -> m b) -> m b
class Monad (metaclass = abc.ABCMeta):
@classmethod
def build (cls, x):
raise NotImplementedError
def bind (self, f):
raise NotImplementedError
# data Maybe a = Just a | Nothing
# deriving (Show)
class Maybe (Monad):
def __init__ (self, x):
self.__x = x
def __repr__ (self):
if self is Nothing:
return "Nothing"
return ("Just %r" % self.__x)
# instance Monad Maybe where
# build x = Just x
#
# bind Nothing _ = Nothing
# bind (Just x) f = f x
@classmethod
def build (cls, x):
return Just (x)
def bind (self, f):
if self is Nothing:
return Nothing
return f (self.__x)
def Just (x):
return Maybe (x)
Nothing = Maybe (None)
# clamp limit x = if x > limit then Nothing else Just x
def clamp (limit, x):
if x > limit:
return Nothing
return Just (x)
# multiclamp2 lim1 lim2 x = bind
# (clamp lim1 x)
# (\x' -> clamp lim2 x')
def multiclamp2 (lim1, lim2, x):
return clamp (lim1, x).bind (lambda x2: clamp (lim2, x2))
http://lamp.epfl.ch/~emir/bqbase/2005/01/20/monad.html has an explanation from scala's perspective. I can understand the first part when the author describes a monad as an object with a polymorphic type, a map function, a flatten function, and a singleton constructor function. Everything they said beyond that goes right over my head.
For me at least, the mathematics line-noise is a bigger issue, and it made more sense once I ignored it. As a programming construct, monads seem quite understandable to me, even clever. But many of the explanations, especially earlier ones, started out with a type-theoretic explanation with links to category theory...
In particular, I was under the misimpression for years, because of it being presented that way, that monads were essentially of interest only for people who were hung up on type-checking: that they were a solution to how to make the type-checking go through on a certain class of problems, by lifting an underlying type into the Monadic type and getting it back out again. As someone who mainly uses dynamically typed languages, this didn't seem of interest, since in Lisp, I don't care if the type-checking goes through or not. It was probably years later that I figured out they had some non-type-related programming benefit.
Inspired by this article. and in a fit of temporary insanity, I implemented a simple monad protocol and the Maybe and List monads in Clojure. It's not fit for use, but it was fun to write.
It may not be immediately evident what is being composed there, but if you look at lift, it breaks the multi-argument "+" operator into several partial applications and composes each of those under the given monad, giving interesting results. This was necessary to maintain support for a variable number of arguments.
Note that the code uses features only available in the git master branch, so you will need a snapshot build to run it.
multiclamp5 :: Ord a => a -> a -> a -> Maybe a
multiclamp5 lim1 lim2 = Kleisli (clamp lim1) >>> Kleisli (clamp lim2)
multiclamp = clamp >=> return clamp
allclamp lims x = foldM (flip clamp) x lims
(>=>) :: (Monad m) => (a -> m b) -> (b -> m c) -> (a -> m c)
(>=>) c1 c2 a = (c1 a) >>= c2
I'd like to be able to tell those jokes without it being like making sounds in a foreign language—that's what I mean by "knowing" Haskell. You can't speak a language until you can make a witty retort in it ;)
That's just computer science -- a bunch of CS stuff is easier to express in Haskell, so we do, but it might need some background.
> here's how to do in Haskell the stuff you already know how to do in Ruby
Try a different tutorial. Maybe: Real World Haskell?
I'll be back to this site in a few weeks to check for progress...