Shae Matijs Erisson wrote:
Gregory Woodhouse <[EMAIL PROTECTED]> writes:
My knowledge of functional programming is pretty much limited to Haskell,
Scheme, and a smattering of Common Lisp. Are there languages other than
Haskell that explicitly use monads? How about "not so explicitly"?
Java http://www.ccs.neu.edu/home/dherman/code/monads/JavaMonads.tar.gz
Joy http://permalink.gmane.org/gmane.comp.lang.concatenative/1506
OCaml
https://mailman.rice.edu/pipermail/metaocaml-users-l/2005-March/000057.html
Perl http://sleepingsquirrel.org/monads/monads.html
Prolog http://logic.csci.unt.edu/tarau/research/PapersHTML/monadic.html
Python http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/439361
Ruby
http://moonbase.rydia.net/mental/writings/programming/monads-in-ruby/00introduction.html
Scheme
http://www.ccs.neu.edu/home/dherman/research/tutorials/monads-for-schemers.txt
Please respond with any language implementations I've missed.
The Java implementation is actually a little baroque because it doesn't
make use of generics. In June when there was a question here at Penn
about how critical type-classes were to the use of Monads, I put
together this quick example:
interface Monad<A> {
public <B> Monad<B> unit(B e);
public <B,C> Monad<C> bind(Monad<B> e, MonadBindFun<B,C> f);
}
interface MonadBindFun<A,B> {
public Monad<B> fun(A x);
}
class OptionMonad<A> implements Monad<A> {
public <B> Monad<B> unit(B e) {
return new Some<B>(e);
}
public <B,C> Monad<C> bind(Monad<B> e, MonadBindFun<B,C> f) {
if(e instanceof Some) {
Some<B> eb = (Some<B>)e;
return f.fun(eb.get());
} else if (e instanceof None) {
return new None<C>();
} else {
throw new Error();
}
}
}
public class None<A> extends OptionMonad<A> implements Monad<A> {
public None() { }
}
public class Some<A> extends OptionMonad<A> implements Monad<A> {
A x = null;
public Some(A x) {
this.x = x;
}
public A get() { return x; }
}
Just a few minutes ago I wrote, but haven't tested the following:
import java.util.*;
public class ListMonad<A> implements Monad<A> {
List<A> list = null;
private ListMonad(List<A> list) {
this.list = list;
}
public <B> ListMonad<B> unit(B e) {
List<B> nlist = new LinkedList<B>();
nlist.add(e);
return new ListMonad(nlist);
}
public <B,C> Monad<C> bind(Monad<B> e, MonadBindFun<B,C> f) {
if(e instanceof ListMonad) {
ListMonad<B> be = (ListMonad<B>)e;
List<List<C>> reslists = new LinkedList<List<C>>();
for(B x : be.list) {
Monad<C> res = f.fun(x);
if(res instanceof ListMonad) {
ListMonad<C> ce = (ListMonad<C>)res;
reslists.add(ce.list);
} else {
throw new Error();
}
}
List<C> flat = new LinkedList<C>();
for(List<C> x : reslists) {
flat.addAll(x);
}
return new ListMonad(flat);
} else {
throw new Error();
}
}
}
I also threw together a slightly cleaner version of these examples using
Scala, but I'm sure the Scala folks could do better than me.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
