diff --git a/prelude/prelude.purs b/prelude/prelude.purs
new file mode 100644
--- /dev/null
+++ b/prelude/prelude.purs
@@ -0,0 +1,944 @@
+module Prelude
+  ( flip
+  , const
+  , asTypeOf
+  , Semigroupoid, (<<<), (>>>)
+  , Category, id
+  , ($), (#)
+  , (:), cons
+  , Show, show
+  , Functor, (<$>), void
+  , Apply, (<*>)
+  , Applicative, pure, liftA1
+  , Bind, (>>=)
+  , Monad, return, liftM1, ap
+  , Num, (+), (-), (*), (/), (%)
+  , negate
+  , Eq, (==), (/=), refEq, refIneq
+  , Ord, Ordering(..), compare, (<), (>), (<=), (>=)
+  , Bits, (&), (|), (^), shl, shr, zshr, complement
+  , BoolLike, (&&), (||)
+  , not
+  , Semigroup, (<>), (++)
+  , Unit(..), unit
+  ) where
+
+  flip :: forall a b c. (a -> b -> c) -> b -> a -> c
+  flip f b a = f a b
+
+  const :: forall a b. a -> b -> a
+  const a _ = a
+
+  asTypeOf :: forall a. a -> a -> a
+  asTypeOf x _ = x
+
+  infixr 9 >>>
+  infixr 9 <<<
+
+  class Semigroupoid a where
+    (<<<) :: forall b c d. a c d -> a b c -> a b d
+
+  instance semigroupoidArr :: Semigroupoid (->) where
+    (<<<) f g x = f (g x)
+
+  (>>>) :: forall a b c d. (Semigroupoid a) => a b c -> a c d -> a b d
+  (>>>) f g = g <<< f
+
+  class (Semigroupoid a) <= Category a where
+    id :: forall t. a t t
+
+  instance categoryArr :: Category (->) where
+    id x = x
+
+  infixr 0 $
+  infixl 0 #
+
+  ($) :: forall a b. (a -> b) -> a -> b
+  ($) f x = f x
+
+  (#) :: forall a b. a -> (a -> b) -> b
+  (#) x f = f x
+
+  infixr 6 :
+
+  (:) :: forall a. a -> [a] -> [a]
+  (:) = cons
+
+  foreign import cons
+    "function cons(e) {\
+    \  return function(l) {\
+    \    return [e].concat(l);\
+    \  };\
+    \}" :: forall a. a -> [a] -> [a]
+
+  class Show a where
+    show :: a -> String
+
+  foreign import showStringImpl
+    "function showStringImpl(s) {\
+    \  return JSON.stringify(s);\
+    \}" :: String -> String
+
+  instance showUnit :: Show Unit where
+    show (Unit {}) = "Unit {}"
+
+  instance showString :: Show String where
+    show = showStringImpl
+
+  instance showBoolean :: Show Boolean where
+    show true = "true"
+    show false = "false"
+
+  foreign import showNumberImpl "function showNumberImpl(n) {\
+                                \  return n.toString();\
+                                \}" :: Number -> String
+
+  instance showNumber :: Show Number where
+    show = showNumberImpl
+
+  foreign import showArrayImpl
+    "function showArrayImpl(f) {\
+    \  return function(xs) {\
+    \    var ss = [];\
+    \    for (var i = 0, l = xs.length; i < l; i++) {\
+    \      ss[i] = f(xs[i]);\
+    \    }\
+    \    return '[' + ss.join(',') + ']';\
+    \  };\
+    \}" :: forall a. (a -> String) -> [a] -> String
+
+  instance showArray :: (Show a) => Show [a] where
+    show = showArrayImpl show
+
+  infixl 4 <$>
+
+  class Functor f where
+    (<$>) :: forall a b. (a -> b) -> f a -> f b
+
+  void :: forall f a. (Functor f) => f a -> f Unit
+  void fa = const unit <$> fa
+
+  infixl 4 <*>
+
+  class (Functor f) <= Apply f where
+    (<*>) :: forall a b. f (a -> b) -> f a -> f b
+
+  class (Apply f) <= Applicative f where
+    pure :: forall a. a -> f a
+
+  liftA1 :: forall f a b. (Applicative f) => (a -> b) -> f a -> f b
+  liftA1 f a = pure f <*> a
+
+  infixl 1 >>=
+
+  class (Apply m) <= Bind m where
+    (>>=) :: forall a b. m a -> (a -> m b) -> m b
+
+  class (Applicative m, Bind m) <= Monad m
+
+  return :: forall m a. (Monad m) => a -> m a
+  return = pure
+
+  liftM1 :: forall m a b. (Monad m) => (a -> b) -> m a -> m b
+  liftM1 f a = do
+    a' <- a
+    return (f a')
+
+  ap :: forall m a b. (Monad m) => m (a -> b) -> m a -> m b
+  ap f a = do
+    f' <- f
+    a' <- a
+    return (f' a')
+
+  instance functorArr :: Functor ((->) r) where
+    (<$>) = (<<<)
+
+  instance applyArr :: Apply ((->) r) where
+    (<*>) f g x = f x (g x)
+
+  instance applicativeArr :: Applicative ((->) r) where
+    pure = const
+
+  instance bindArr :: Bind ((->) r) where
+    (>>=) m f x = f (m x) x
+
+  instance monadArr :: Monad ((->) r)
+
+  infixl 7 *
+  infixl 7 /
+  infixl 7 %
+
+  infixl 6 -
+  infixl 6 +
+
+  class Num a where
+    (+) :: a -> a -> a
+    (-) :: a -> a -> a
+    (*) :: a -> a -> a
+    (/) :: a -> a -> a
+    (%) :: a -> a -> a
+    negate :: a -> a
+
+  foreign import numAdd "function numAdd(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 + n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numSub "function numSub(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 - n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numMul "function numMul(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 * n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numDiv "function numDiv(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 / n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numMod "function numMod(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 % n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numNegate "function numNegate(n) {\
+                           \  return -n;\
+                           \}" :: Number -> Number
+
+  instance numNumber :: Num Number where
+    (+) = numAdd
+    (-) = numSub
+    (*) = numMul
+    (/) = numDiv
+    (%) = numMod
+    negate = numNegate
+
+  newtype Unit = Unit {}
+
+  unit :: Unit
+  unit = Unit {}
+
+  infix 4 ==
+  infix 4 /=
+
+  class Eq a where
+    (==) :: a -> a -> Boolean
+    (/=) :: a -> a -> Boolean
+
+  foreign import refEq
+    "function refEq(r1) {\
+    \  return function(r2) {\
+    \    return r1 === r2;\
+    \  };\
+    \}" :: forall a. a -> a -> Boolean
+
+  foreign import refIneq
+    "function refIneq(r1) {\
+    \  return function(r2) {\
+    \    return r1 !== r2;\
+    \  };\
+    \}" :: forall a. a -> a -> Boolean
+
+  instance eqUnit :: Eq Unit where
+    (==) (Unit {}) (Unit {}) = true
+    (/=) (Unit {}) (Unit {}) = false
+
+  instance eqString :: Eq String where
+    (==) = refEq
+    (/=) = refIneq
+
+  instance eqNumber :: Eq Number where
+    (==) = refEq
+    (/=) = refIneq
+
+  instance eqBoolean :: Eq Boolean where
+    (==) = refEq
+    (/=) = refIneq
+
+  foreign import eqArrayImpl
+    "function eqArrayImpl(f) {\
+    \  return function(xs) {\
+    \    return function(ys) {\
+    \      if (xs.length !== ys.length) return false;\
+    \      for (var i = 0; i < xs.length; i++) {\
+    \        if (!f(xs[i])(ys[i])) return false;\
+    \      }\
+    \      return true;\
+    \    };\
+    \  };\
+    \}" :: forall a. (a -> a -> Boolean) -> [a] -> [a] -> Boolean
+
+  instance eqArray :: (Eq a) => Eq [a] where
+    (==) xs ys = eqArrayImpl (==) xs ys
+    (/=) xs ys = not (xs == ys)
+
+  data Ordering = LT | GT | EQ
+
+  instance eqOrdering :: Eq Ordering where
+    (==) LT LT = true
+    (==) GT GT = true
+    (==) EQ EQ = true
+    (==) _  _  = false
+    (/=) x y = not (x == y)
+
+  instance showOrdering :: Show Ordering where
+    show LT = "LT"
+    show GT = "GT"
+    show EQ = "EQ"
+
+  class (Eq a) <= Ord a where
+    compare :: a -> a -> Ordering
+
+  infixl 4 <
+
+  (<) :: forall a. (Ord a) => a -> a -> Boolean
+  (<) a1 a2 = case a1 `compare` a2 of
+    LT -> true
+    _ -> false
+
+  infixl 4 >
+
+  (>) :: forall a. (Ord a) => a -> a -> Boolean
+  (>) a1 a2 = case a1 `compare` a2 of
+    GT -> true
+    _ -> false
+
+  infixl 4 <=
+
+  (<=) :: forall a. (Ord a) => a -> a -> Boolean
+  (<=) a1 a2 = case a1 `compare` a2 of
+    GT -> false
+    _ -> true
+
+  infixl 4 >=
+
+  (>=) :: forall a. (Ord a) => a -> a -> Boolean
+  (>=) a1 a2 = case a1 `compare` a2 of
+    LT -> false
+    _ -> true
+
+  foreign import unsafeCompareImpl
+    "function unsafeCompareImpl(lt) {\
+    \  return function(eq) {\
+    \    return function(gt) {\
+    \      return function(x) {\
+    \        return function(y) {\
+    \          return x < y ? lt : x > y ? gt : eq;\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a. Ordering -> Ordering -> Ordering -> a -> a -> Ordering
+
+  unsafeCompare :: forall a. a -> a -> Ordering
+  unsafeCompare = unsafeCompareImpl LT EQ GT
+
+  instance ordUnit :: Ord Unit where
+    compare (Unit {}) (Unit {}) = EQ
+
+  instance ordBoolean :: Ord Boolean where
+    compare false false = EQ
+    compare false true  = LT
+    compare true  true  = EQ
+    compare true  false = GT
+
+  instance ordNumber :: Ord Number where
+    compare = unsafeCompare
+
+  instance ordString :: Ord String where
+    compare = unsafeCompare
+
+  instance ordArray :: (Ord a) => Ord [a] where
+    compare [] [] = EQ
+    compare [] _ = LT
+    compare _ [] = GT
+    compare (x:xs) (y:ys) = case compare x y of
+      EQ -> compare xs ys
+      other -> other
+
+  infixl 10 &
+  infixl 10 |
+  infixl 10 ^
+
+  class Bits b where
+    (&) :: b -> b -> b
+    (|) :: b -> b -> b
+    (^) :: b -> b -> b
+    shl :: b -> Number -> b
+    shr :: b -> Number -> b
+    zshr :: b -> Number -> b
+    complement :: b -> b
+
+  foreign import numShl "function numShl(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 << n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numShr "function numShr(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 >> n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numZshr "function numZshr(n1) {\
+                          \  return function(n2) {\
+                          \    return n1 >>> n2;\
+                          \  };\
+                          \}" :: Number -> Number -> Number
+
+  foreign import numAnd "function numAnd(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 & n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numOr "function numOr(n1) {\
+                       \  return function(n2) {\
+                       \    return n1 | n2;\
+                       \  };\
+                       \}" :: Number -> Number -> Number
+
+  foreign import numXor "function numXor(n1) {\
+                        \  return function(n2) {\
+                        \    return n1 ^ n2;\
+                        \  };\
+                        \}" :: Number -> Number -> Number
+
+  foreign import numComplement "function numComplement(n) {\
+                               \  return ~n;\
+                               \}" :: Number -> Number
+
+  instance bitsNumber :: Bits Number where
+    (&) = numAnd
+    (|) = numOr
+    (^) = numXor
+    shl = numShl
+    shr = numShr
+    zshr = numZshr
+    complement = numComplement
+
+  infixr 2 ||
+  infixr 3 &&
+
+  class BoolLike b where
+    (&&) :: b -> b -> b
+    (||) :: b -> b -> b
+    not :: b -> b
+
+  foreign import boolAnd "function boolAnd(b1) {\
+                         \  return function(b2) {\
+                         \    return b1 && b2;\
+                         \  };\
+                         \}"  :: Boolean -> Boolean -> Boolean
+
+  foreign import boolOr "function boolOr(b1) {\
+                        \  return function(b2) {\
+                        \    return b1 || b2;\
+                        \  };\
+                        \}" :: Boolean -> Boolean -> Boolean
+
+  foreign import boolNot "function boolNot(b) {\
+                         \  return !b;\
+                         \}" :: Boolean -> Boolean
+
+  instance boolLikeBoolean :: BoolLike Boolean where
+    (&&) = boolAnd
+    (||) = boolOr
+    not = boolNot
+
+  infixr 5 <>
+
+  class Semigroup a where
+    (<>) :: a -> a -> a
+
+  foreign import concatString
+    "function concatString(s1) {\
+    \  return function(s2) {\
+    \    return s1 + s2;\
+    \  };\
+    \}" :: String -> String -> String
+
+  instance semigroupUnit :: Semigroup Unit where
+    (<>) (Unit {}) (Unit {}) = Unit {}
+
+  instance semigroupString :: Semigroup String where
+    (<>) = concatString
+
+  instance semigroupArr :: (Semigroup s') => Semigroup (s -> s') where
+    (<>) f g = \x -> f x <> g x
+
+  infixr 5 ++
+
+  (++) :: forall s. (Semigroup s) => s -> s -> s
+  (++) = (<>)
+
+module Data.Function where
+
+  on :: forall a b c. (b -> b -> c) -> (a -> b) -> a -> a -> c
+  on f g x y = g x `f` g y
+
+  foreign import data Fn0 :: * -> *
+  foreign import data Fn1 :: * -> * -> *
+  foreign import data Fn2 :: * -> * -> * -> *
+  foreign import data Fn3 :: * -> * -> * -> * -> *
+  foreign import data Fn4 :: * -> * -> * -> * -> * -> *
+  foreign import data Fn5 :: * -> * -> * -> * -> * -> * -> *
+  foreign import data Fn6 :: * -> * -> * -> * -> * -> * -> * -> *
+  foreign import data Fn7 :: * -> * -> * -> * -> * -> * -> * -> * -> *
+  foreign import data Fn8 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> *
+  foreign import data Fn9 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
+  foreign import data Fn10 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
+
+  foreign import mkFn0
+    "function mkFn0(fn) {\
+    \  return function() {\
+    \    return fn({});\
+    \  };\
+    \}" :: forall a. (Unit -> a) -> Fn0 a
+
+  foreign import mkFn1
+    "function mkFn1(fn) {\
+    \  return function(a) {\
+    \    return fn(a);\
+    \  };\
+    \}" :: forall a b. (a -> b) -> Fn1 a b
+
+  foreign import mkFn2
+    "function mkFn2(fn) {\
+    \  return function(a, b) {\
+    \    return fn(a)(b);\
+    \  };\
+    \}" :: forall a b c. (a -> b -> c) -> Fn2 a b c
+
+  foreign import mkFn3
+    "function mkFn3(fn) {\
+    \  return function(a, b, c) {\
+    \    return fn(a)(b)(c);\
+    \  };\
+    \}" :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d
+
+  foreign import mkFn4
+    "function mkFn4(fn) {\
+    \  return function(a, b, c, d) {\
+    \    return fn(a)(b)(c)(d);\
+    \  };\
+    \}" :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e
+
+  foreign import mkFn5
+    "function mkFn5(fn) {\
+    \  return function(a, b, c, d, e) {\
+    \    return fn(a)(b)(c)(d)(e);\
+    \  };\
+    \}" :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f
+
+  foreign import mkFn6
+    "function mkFn6(fn) {\
+    \  return function(a, b, c, d, e, f) {\
+    \    return fn(a)(b)(c)(d)(e)(f);\
+    \  };\
+    \}" :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g
+
+  foreign import mkFn7
+    "function mkFn7(fn) {\
+    \  return function(a, b, c, d, e, f, g) {\
+    \    return fn(a)(b)(c)(d)(e)(f)(g);\
+    \  };\
+    \}" :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> Fn7 a b c d e f g h
+
+  foreign import mkFn8
+    "function mkFn8(fn) {\
+    \  return function(a, b, c, d, e, f, g, h) {\
+    \    return fn(a)(b)(c)(d)(e)(f)(g)(h);\
+    \  };\
+    \}" :: forall a b c d e f g h i. (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Fn8 a b c d e f g h i
+
+  foreign import mkFn9
+    "function mkFn9(fn) {\
+    \  return function(a, b, c, d, e, f, g, h, i) {\
+    \    return fn(a)(b)(c)(d)(e)(f)(g)(h)(i);\
+    \  };\
+    \}" :: forall a b c d e f g h i j. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> Fn9 a b c d e f g h i j
+
+  foreign import mkFn10
+    "function mkFn10(fn) {\
+    \  return function(a, b, c, d, e, f, g, h, i, j) {\
+    \    return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)(j);\
+    \  };\
+    \}" :: forall a b c d e f g h i j k. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> Fn10 a b c d e f g h i j k
+
+  foreign import runFn0
+    "function runFn0(fn) {\
+    \  return fn();\
+    \}" :: forall a. Fn0 a -> a
+
+  foreign import runFn1
+    "function runFn1(fn) {\
+    \  return function(a) {\
+    \    return fn(a);\
+    \  };\
+    \}" :: forall a b. Fn1 a b -> a -> b
+
+  foreign import runFn2
+    "function runFn2(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return fn(a, b);\
+    \    };\
+    \  };\
+    \}" :: forall a b c. Fn2 a b c -> a -> b -> c
+
+  foreign import runFn3
+    "function runFn3(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return fn(a, b, c);\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d
+
+  foreign import runFn4
+    "function runFn4(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return function(d) {\
+    \          return fn(a, b, c, d);\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e
+
+  foreign import runFn5
+    "function runFn5(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return function(d) {\
+    \          return function(e) {\
+    \            return fn(a, b, c, d, e);\
+    \          };\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f
+
+  foreign import runFn6
+    "function runFn6(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return function(d) {\
+    \          return function(e) {\
+    \            return function(f) {\
+    \              return fn(a, b, c, d, e, f);\
+    \            };\
+    \          };\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g
+
+  foreign import runFn7
+    "function runFn7(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return function(d) {\
+    \          return function(e) {\
+    \            return function(f) {\
+    \              return function(g) {\
+    \                return fn(a, b, c, d, e, f, g);\
+    \              };\
+    \            };\
+    \          };\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d e f g h. Fn7 a b c d e f g h -> a -> b -> c -> d -> e -> f -> g -> h
+
+  foreign import runFn8
+    "function runFn8(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return function(d) {\
+    \          return function(e) {\
+    \            return function(f) {\
+    \              return function(g) {\
+    \                return function(h) {\
+    \                  return fn(a, b, c, d, e, f, g, h);\
+    \                };\
+    \              };\
+    \            };\
+    \          };\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d e f g h i. Fn8 a b c d e f g h i -> a -> b -> c -> d -> e -> f -> g -> h -> i
+
+  foreign import runFn9
+    "function runFn9(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return function(d) {\
+    \          return function(e) {\
+    \            return function(f) {\
+    \              return function(g) {\
+    \                return function(h) {\
+    \                  return function(i) {\
+    \                    return fn(a, b, c, d, e, f, g, h, i);\
+    \                  };\
+    \                };\
+    \              };\
+    \            };\
+    \          };\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d e f g h i j. Fn9 a b c d e f g h i j -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j
+
+  foreign import runFn10
+    "function runFn10(fn) {\
+    \  return function(a) {\
+    \    return function(b) {\
+    \      return function(c) {\
+    \        return function(d) {\
+    \          return function(e) {\
+    \            return function(f) {\
+    \              return function(g) {\
+    \                return function(h) {\
+    \                  return function(i) {\
+    \                    return function(j) {\
+    \                      return fn(a, b, c, d, e, f, g, h, i, j);\
+    \                    };\
+    \                  };\
+    \                };\
+    \              };\
+    \            };\
+    \          };\
+    \        };\
+    \      };\
+    \    };\
+    \  };\
+    \}" :: forall a b c d e f g h i j k. Fn10 a b c d e f g h i j k -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
+
+module Data.Eq where
+
+  newtype Ref a = Ref a
+
+  liftRef :: forall a b. (a -> a -> b) -> Ref a -> Ref a -> b
+  liftRef f (Ref x) (Ref y) = f x y
+
+  instance eqRef :: Eq (Ref a) where
+    (==) = liftRef refEq
+    (/=) = liftRef refIneq
+
+  instance functorRef :: Functor Ref where
+    (<$>) f (Ref x) = Ref (f x)
+
+module Prelude.Unsafe where
+
+  foreign import unsafeIndex
+    "function unsafeIndex(xs) {\
+    \  return function(n) {\
+    \    return xs[n];\
+    \  };\
+    \}" :: forall a. [a] -> Number -> a
+
+module Control.Monad.Eff where
+
+  foreign import data Eff :: # ! -> * -> *
+
+  foreign import returnE "function returnE(a) {\
+                         \  return function() {\
+                         \    return a;\
+                         \  };\
+                         \}" :: forall e a. a -> Eff e a
+
+  foreign import bindE "function bindE(a) {\
+                       \  return function(f) {\
+                       \    return function() {\
+                       \      return f(a())();\
+                       \    };\
+                       \  };\
+                       \}" :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b
+
+  type Pure a = forall e. Eff e a
+
+  foreign import runPure "function runPure(f) {\
+                         \  return f();\
+                         \}" :: forall a. Pure a -> a
+
+  instance functorEff :: Functor (Eff e) where
+    (<$>) = liftA1
+
+  instance applyEff :: Apply (Eff e) where
+    (<*>) = ap
+
+  instance applicativeEff :: Applicative (Eff e) where
+    pure = returnE
+
+  instance bindEff :: Bind (Eff e) where
+    (>>=) = bindE
+
+  instance monadEff :: Monad (Eff e)
+
+  foreign import untilE "function untilE(f) {\
+                        \  return function() {\
+                        \    while (!f());\
+                        \    return {};\
+                        \  };\
+                        \}" :: forall e. Eff e Boolean -> Eff e Unit
+
+  foreign import whileE "function whileE(f) {\
+                        \  return function(a) {\
+                        \    return function() {\
+                        \      while (f()) {\
+                        \        a();\
+                        \      }\
+                        \      return {};\
+                        \    };\
+                        \  };\
+                        \}" :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
+
+  foreign import forE "function forE(lo) {\
+                      \  return function(hi) {\
+                      \    return function(f) {\
+                      \      return function() {\
+                      \        for (var i = lo; i < hi; i++) {\
+                      \          f(i)();\
+                      \        }\
+                      \      };\
+                      \    };\
+                      \  };\
+                      \}" :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
+
+
+  foreign import foreachE "function foreachE(as) {\
+                          \  return function(f) {\
+                          \    return function() {\
+                          \      for (var i = 0; i < as.length; i++) {\
+                          \        f(as[i])();\
+                          \      }\
+                          \    };\
+                          \  };\
+                          \}" :: forall e a. [a] -> (a -> Eff e Unit) -> Eff e Unit
+
+module Control.Monad.Eff.Unsafe where
+
+  import Control.Monad.Eff
+
+  foreign import unsafeInterleaveEff
+    "function unsafeInterleaveEff(f) {\
+    \  return f;\
+    \}" :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
+
+module Debug.Trace where
+
+  import Control.Monad.Eff
+
+  foreign import data Trace :: !
+
+  foreign import trace "function trace(s) {\
+                       \  return function() {\
+                       \    console.log(s);\
+                       \    return {};\
+                       \  };\
+                       \}" :: forall r. String -> Eff (trace :: Trace | r) Unit
+
+  print :: forall a r. (Show a) => a -> Eff (trace :: Trace | r) Unit
+  print o = trace (show o)
+
+module Control.Monad.ST where
+
+  import Control.Monad.Eff
+
+  foreign import data ST :: * -> !
+
+  foreign import data STRef :: * -> * -> *
+
+  foreign import data STArray :: * -> * -> *
+
+  foreign import newSTRef "function newSTRef(val) {\
+                          \  return function() {\
+                          \    return { value: val };\
+                          \  };\
+                          \}" :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)
+
+  foreign import readSTRef "function readSTRef(ref) {\
+                           \  return function() {\
+                           \    return ref.value;\
+                           \  };\
+                           \}" :: forall a h r. STRef h a -> Eff (st :: ST h | r) a
+
+  foreign import modifySTRef "function modifySTRef(ref) {\
+                             \  return function(f) {\
+                             \    return function() {\
+                             \      return ref.value = f(ref.value);\
+                             \    };\
+                             \  };\
+                             \}" :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a
+
+  foreign import writeSTRef "function writeSTRef(ref) {\
+                            \  return function(a) {\
+                            \    return function() {\
+                            \      return ref.value = a;\
+                            \    };\
+                            \  };\
+                            \}" :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a
+
+  foreign import newSTArray "function newSTArray(len) {\
+                            \  return function(a) {\
+                            \    return function() {\
+                            \      var arr = [];\
+                            \      for (var i = 0; i < len; i++) {\
+                            \        arr[i] = a;\
+                            \      };\
+                            \      return arr;\
+                            \    };\
+                            \  };\
+                            \}" :: forall a h r. Number -> a -> Eff (st :: ST h | r) (STArray h a)
+
+  foreign import peekSTArray "function peekSTArray(arr) {\
+                             \  return function(i) {\
+                             \    return function() {\
+                             \      return arr[i];\
+                             \    };\
+                             \  };\
+                             \}" :: forall a h r. STArray h a -> Number -> Eff (st :: ST h | r) a
+
+  foreign import pokeSTArray "function pokeSTArray(arr) {\
+                             \  return function(i) {\
+                             \    return function(a) {\
+                             \      return function() {\
+                             \        return arr[i] = a;\
+                             \      };\
+                             \    };\
+                             \  };\
+                             \}" :: forall a h r. STArray h a -> Number -> a -> Eff (st :: ST h | r) a
+
+  foreign import runST "function runST(f) {\
+                       \  return f;\
+                       \}" :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a
+
+  foreign import runSTArray "function runSTArray(f) {\
+                            \  return f;\
+                            \}" :: forall a r. (forall h. Eff (st :: ST h | r) (STArray h a)) -> Eff r [a]
diff --git a/purescript.cabal b/purescript.cabal
--- a/purescript.cabal
+++ b/purescript.cabal
@@ -1,5 +1,5 @@
 name: purescript
-version: 0.6.0
+version: 0.6.0.1
 cabal-version: >=1.8
 build-type: Simple 
 license: MIT
@@ -15,7 +15,8 @@
         Gary Burgess <gary.burgess@gmail.com>,
         Hardy Jones <jones3.hardy@gmail.com>
 
-extra-source-files: examples/passing/*.purs
+extra-source-files: prelude/prelude.purs
+                  , examples/passing/*.purs
                   , examples/failing/*.purs
 
 source-repository head