purescript 0.6.3 → 0.6.4

raw patch · 16 files changed

+1096/−936 lines, 16 filesdep ~utf8-stringPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: utf8-string

API changes (from Hackage documentation)

Files

• examples/failing/UnknownValue.purs +0/−25
• examples/passing/CheckFunction.purs +5/−0
• examples/passing/OperatorAssociativity.purs +25/−4
• examples/passing/Operators.purs +12/−0
• hierarchy/Main.hs +5/−6
• prelude/prelude.purs +985/−845
• psc-docs/Main.hs +5/−6
• psc-make/Main.hs +9/−10
• psc/Main.hs +9/−10
• psci/Main.hs +7/−8
• purescript.cabal +8/−8
• src/Language/PureScript/CoreFn/Desugar.hs +5/−0
• src/Language/PureScript/Pretty/JS.hs +18/−9
• src/Language/PureScript/Sugar/Operators.hs +0/−2
• src/Language/PureScript/TypeChecker/Types.hs +2/−1
• tests/Main.hs +1/−2

@@ -1,25 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.ST-import Debug.Trace--test = runSTArray (do-  a <- newSTArray 2 0-  pokeSTArray a 0 1-  pokeSTArray a 1 2-  return a)--fromTo lo hi = runSTArray (do-  arr <- newSTArray (hi - lo + 1) 0-  (let-    go lo hi _ arr | lo > hi = return arr-    go lo hi i arr = do-      pokeSTArray arrr i lo-      go (lo + 1) hi (i + 1) arr-   in go lo hi 0 arr))--main = do-  let t1 = runPure (fromTo 10 20)-  trace "Done"

@@ -0,0 +1,5 @@+module Main where++test = ((\x -> x+1) >>> (\x -> x*2)) 4++main = Debug.Trace.trace "Done"

@@ -1,15 +1,36 @@ module Main where  import Control.Monad.Eff+import Debug.Trace +foreign import data Assert :: !++foreign import assert+  "function assert(x) { return function (desc) {\+  \  return function () {\+  \    if (!x) throw new Error('assertion (' + desc + ') failed');\+  \    return {};\+  \  };\+  \};};" :: forall e. Boolean -> String -> Eff (assert :: Assert | e) Unit+ bug :: Number -> Number -> Number bug a b = 0 - (a - b) -foreign import explode +foreign import explode   "function explode() {\   \  throw new Error('Assertion failed!');\   \}":: forall eff a. Eff eff a -main = case bug 0 2 of-  2 -> Debug.Trace.trace "Done!"-  _ -> explode+main = do+    assert (bug 0 2 == 2)       "bug 0 2 == 2"+    assert (0 - (0 - 2) == 2)   "0 - (0 - 2) == 2"+    assert (0 - (0 + 2) == -2)  "0 - (0 + 2) == -2"++    assert (6 / (3 * 2) == 1)   "6 / (3 * 2) == 1"+    assert ((6 / 3) * 2 == 4)   "(6 / 3) * 2 == 4"++    assert (6 % (2 * 2) == 2)   "6 % (2 * 2) == 2"+    assert ((6 % 2) * 2 == 0)   "(6 % 2) * 2 == 0"++    assert (4 % (9 / 3) == 1)   "4 % (9 / 3) == 1"+    assert ((4 % 9) / 2 == 2)   "(4 % 9) / 2 == 2"

@@ -64,6 +64,15 @@   test16 :: Number -> Number -> Number    test16 x y = x .|. y .&. y +  test17 :: Number+  test17 = negate (-1)++  test18 :: Number+  test18 = negate $ negate 1++  test19 :: Number+  test19 = negate $ negate (-1)+   main = do     let t1 = test1 1 2 (\x y -> x + y)     let t2 = test2@@ -81,4 +90,7 @@     let t14 = test14 1 2     let t15 = test15 1 2     let t16 = test16 1 2+    let t17 = test17+    let t18 = test18+    let t19 = test19     trace "Done"

@@ -25,13 +25,12 @@ import System.Directory (createDirectoryIfMissing) import System.FilePath ((</>)) import System.Exit (exitFailure, exitSuccess)-import System.IO (stderr)+import System.IO (hPutStr, stderr)  import Text.Parsec as Par (ParseError)  import qualified Language.PureScript as P import qualified Paths_purescript as Paths-import qualified System.IO.UTF8 as U   data HierarchyOptions = HierarchyOptions@@ -56,14 +55,14 @@  readInput :: FilePath -> IO (Either Par.ParseError [P.Module]) readInput filename = do-  content <- U.readFile filename+  content <- readFile filename   return $ fmap (map snd) $ P.parseModulesFromFiles id [(filename, content)]  compile :: HierarchyOptions -> IO () compile (HierarchyOptions input mOutput) = do   modules <- readInput input   case modules of-    Left err -> U.hPutStr stderr (show err) >> exitFailure+    Left err -> hPutStr stderr (show err) >> exitFailure     Right ms -> do       for_ ms $ \(P.Module moduleName decls _) ->         let name = runModuleName moduleName@@ -76,8 +75,8 @@         in unless (null supers) $ case mOutput of           Just output -> do             createDirectoryIfMissing True output-            U.writeFile (output </> name) hier-          Nothing -> U.putStrLn hier+            writeFile (output </> name) hier+          Nothing -> putStrLn hier       exitSuccess  superClasses :: P.Declaration -> [SuperMap]

@@ -69,851 +69,991 @@   (:) = 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 <$>-  infixl 1 <#>--  class Functor f where-    (<$>) :: forall a b. (a -> b) -> f a -> f b--  (<#>) :: forall f a b. (Functor f) => f a -> (a -> b) -> f b-  (<#>) fa f = f <$> fa--  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 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 runST "function runST(f) {\-                       \  return f;\-                       \}" :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a+    """+    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 <$>+  infixl 1 <#>++  class Functor f where+    (<$>) :: forall a b. (a -> b) -> f a -> f b++  (<#>) :: forall f a b. (Functor f) => f a -> (a -> b) -> f b+  (<#>) fa f = f <$> fa++  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 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 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 runST+    """+    function runST(f) {+      return f;+    }+    """ :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a    pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a   pureST st = runPure (runST st)

@@ -27,9 +27,8 @@  import qualified Language.PureScript as P import qualified Paths_purescript as Paths-import qualified System.IO.UTF8 as U import System.Exit (exitSuccess, exitFailure)-import System.IO (stderr)+import System.IO (hPutStr, stderr)   data PSCDocsOptions = PSCDocsOptions@@ -43,14 +42,14 @@   e <- P.parseModulesFromFiles (fromMaybe "") <$> mapM (fmap (first Just) . parseFile) (nub input)   case e of     Left err -> do-      U.hPutStr stderr $ show err+      hPutStr stderr $ show err       exitFailure     Right ms -> do-      U.putStrLn . runDocs $ (renderModules showHierarchy) (map snd ms)+      putStrLn . runDocs $ (renderModules showHierarchy) (map snd ms)       exitSuccess  parseFile :: FilePath -> IO (FilePath, String)-parseFile input = (,) input <$> U.readFile input+parseFile input = (,) input <$> readFile input  type Docs = Writer [String] () @@ -215,7 +214,7 @@ inputFile :: Parser FilePath inputFile = strArgument $      metavar "FILE"-  <> help "The input .ps file(s)"+  <> help "The input .purs file(s)"  includeHeirarcy :: Parser Bool includeHeirarcy = switch $ 

@@ -31,7 +31,6 @@  import qualified Language.PureScript as P import qualified Paths_purescript as Paths-import qualified System.IO.UTF8 as U   data PSCMakeOptions = PSCMakeOptions@@ -48,7 +47,7 @@  readInput :: InputOptions -> IO [(Either P.RebuildPolicy FilePath, String)] readInput InputOptions{..} = do-  content <- forM ioInputFiles $ \inFile -> (Right inFile, ) <$> U.readFile inFile+  content <- forM ioInputFiles $ \inFile -> (Right inFile, ) <$> readFile inFile   return (if ioNoPrelude then content else (Left P.RebuildNever, P.prelude) : content)  newtype Make a = Make { unMake :: ErrorT String IO a } deriving (Functor, Applicative, Monad, MonadIO, MonadError String)@@ -66,27 +65,27 @@       True -> Just <$> getModificationTime path       False -> return Nothing   readTextFile path = makeIO $ do-    U.putStrLn $ "Reading " ++ path-    U.readFile path+    putStrLn $ "Reading " ++ path+    readFile path   writeTextFile path text = makeIO $ do     mkdirp path-    U.putStrLn $ "Writing " ++ path-    U.writeFile path text+    putStrLn $ "Writing " ++ path+    writeFile path text   liftError = either throwError return-  progress = makeIO . U.putStrLn+  progress = makeIO . putStrLn  compile :: PSCMakeOptions -> IO () compile (PSCMakeOptions input outputDir opts usePrefix) = do   modules <- P.parseModulesFromFiles (either (const "") id) <$> readInput (InputOptions (P.optionsNoPrelude opts) input)   case modules of     Left err -> do-      U.print err+      print err       exitFailure     Right ms -> do       e <- runMake $ P.make outputDir opts ms prefix       case e of         Left err -> do-          U.putStrLn err+          putStrLn err           exitFailure         Right _ -> do           exitSuccess@@ -101,7 +100,7 @@ inputFile :: Parser FilePath inputFile = strArgument $      metavar "FILE"-  <> help "The input .ps file(s)"+  <> help "The input .purs file(s)"  outputDirectory :: Parser FilePath outputDirectory = strOption $

@@ -26,11 +26,10 @@ import System.Directory (createDirectoryIfMissing) import System.FilePath (takeDirectory) import System.Exit (exitSuccess, exitFailure)-import System.IO (stderr)+import System.IO (hPutStr, hPutStrLn, stderr)  import qualified Language.PureScript as P import qualified Paths_purescript as Paths-import qualified System.IO.UTF8 as U   data PSCOptions = PSCOptions@@ -51,7 +50,7 @@ readInput :: InputOptions -> IO [(Maybe FilePath, String)] readInput InputOptions{..}   | ioUseStdIn = return . (Nothing ,) <$> getContents-  | otherwise = do content <- forM ioInputFiles $ \inFile -> (Just inFile, ) <$> U.readFile inFile+  | otherwise = do content <- forM ioInputFiles $ \inFile -> (Just inFile, ) <$> readFile inFile                    return (if ioNoPrelude then content else (Nothing, P.prelude) : content)  compile :: PSCOptions -> IO ()@@ -59,19 +58,19 @@   modules <- P.parseModulesFromFiles (fromMaybe "") <$> readInput (InputOptions (P.optionsNoPrelude opts) stdin input)   case modules of     Left err -> do-      U.hPutStr stderr $ show err+      hPutStr stderr $ show err       exitFailure     Right ms -> do       case P.compile opts (map snd ms) prefix of         Left err -> do-          U.hPutStrLn stderr err+          hPutStrLn stderr err           exitFailure         Right (js, exts, _) -> do           case output of-            Just path -> mkdirp path >> U.writeFile path js-            Nothing -> U.putStrLn js+            Just path -> mkdirp path >> writeFile path js+            Nothing -> putStrLn js           case externs of-            Just path -> mkdirp path >> U.writeFile path exts+            Just path -> mkdirp path >> writeFile path exts             Nothing -> return ()           exitSuccess   where@@ -147,7 +146,7 @@ inputFile :: Parser FilePath inputFile = strArgument $      metavar "FILE"-  <> help "The input .ps file(s)"+  <> help "The input .purs file(s)"  outputFile :: Parser (Maybe FilePath) outputFile = optional . strOption $@@ -159,7 +158,7 @@ externsFile = optional . strOption $      short 'e'   <> long "externs"-  <> help "The output .e.ps file"+  <> help "The output .e.purs file"  noPrefix :: Parser Bool noPrefix = switch $ 

@@ -42,7 +42,6 @@ import System.FilePath (pathSeparator, takeDirectory, (</>), isPathSeparator) import System.IO.Error (tryIOError) import System.Process (readProcessWithExitCode)-import qualified System.IO.UTF8 as U (writeFile, putStrLn, print, readFile)  import qualified Text.Parsec as Par (ParseError) @@ -129,7 +128,7 @@ -- loadModule :: FilePath -> IO (Either String [P.Module]) loadModule filename = do-  content <- U.readFile filename+  content <- readFile filename   return $ either (Left . show) (Right . map snd) $ P.parseModulesFromFiles id [(filename, content)]  -- |@@ -138,7 +137,7 @@ loadAllModules :: [FilePath] -> IO (Either Par.ParseError [(Either P.RebuildPolicy FilePath, P.Module)]) loadAllModules files = do   filesAndContent <- forM files $ \filename -> do-    content <- U.readFile filename+    content <- readFile filename     return (Right filename, content)   return $ P.parseModulesFromFiles (either (const "") id) $ (Left P.RebuildNever, P.prelude) : filesAndContent @@ -329,12 +328,12 @@     if exists       then Just <$> getModificationTime path       else return Nothing-  readTextFile path = makeIO $ U.readFile path+  readTextFile path = makeIO $ readFile path   writeTextFile path text = makeIO $ do     mkdirp path-    U.writeFile path text+    writeFile path text   liftError = either throwError return-  progress s = unless (s == "Compiling $PSCI") $ makeIO . U.putStrLn $ s+  progress s = unless (s == "Compiling $PSCI") $ makeIO . putStrLn $ s  mkdirp :: FilePath -> IO () mkdirp = createDirectoryIfMissing True . takeDirectory@@ -579,9 +578,9 @@   exists <- doesFileExist configFile   if exists   then do-    ls <- lines <$> U.readFile configFile+    ls <- lines <$> readFile configFile     case mapM parseCommand ls of-      Left err -> U.print err >> exitFailure+      Left err -> print err >> exitFailure       Right cs -> return $ Just cs   else     return Nothing

@@ -1,5 +1,5 @@ name: purescript-version: 0.6.3+version: 0.6.4 cabal-version: >=1.8 build-type: Simple license: MIT@@ -32,7 +32,7 @@                    mtl >= 2.1.0 && < 2.3.0,                    parsec -any,                    transformers >= 0.3 && < 0.5,-                   utf8-string -any,+                   utf8-string >= 1 && < 2,                    pattern-arrows >= 0.0.2 && < 0.1,                    monad-unify >= 0.2.2 && < 0.3,                    file-embed >= 0.0.7 && < 0.0.8,@@ -119,7 +119,7 @@ executable psc     build-depends: base >=4 && <5, containers -any, directory -any, filepath -any,                    mtl -any, optparse-applicative >= 0.10.0, parsec -any, purescript -any,-                   transformers -any, utf8-string -any+                   transformers -any     main-is: Main.hs     buildable: True     hs-source-dirs: psc@@ -129,7 +129,7 @@ executable psc-make     build-depends: base >=4 && <5, containers -any, directory -any, filepath -any,                    mtl -any, optparse-applicative >= 0.10.0, parsec -any, purescript -any,-                   transformers -any, utf8-string -any+                   transformers -any     main-is: Main.hs     buildable: True     hs-source-dirs: psc-make@@ -140,7 +140,7 @@     build-depends: base >=4 && <5, containers -any, directory -any, filepath -any,                    mtl -any, optparse-applicative >= 0.10.0, parsec -any,                    haskeline >= 0.7.0.0, purescript -any, transformers -any,-                   utf8-string -any, process -any+                   process -any      main-is: Main.hs     buildable: True@@ -150,7 +150,7 @@     ghc-options: -Wall -fno-warn-warnings-deprecations -O2  executable psc-docs-    build-depends: base >=4 && <5, purescript -any, utf8-string -any,+    build-depends: base >=4 && <5, purescript -any,                     optparse-applicative >= 0.10.0, process -any, mtl -any     main-is: Main.hs     buildable: True@@ -159,7 +159,7 @@     ghc-options: -Wall -fno-warn-warnings-deprecations -O2  executable hierarchy-    build-depends: base >=4 && <5, purescript -any, utf8-string -any, optparse-applicative >= 0.10.0,+    build-depends: base >=4 && <5, purescript -any, optparse-applicative >= 0.10.0,                    process -any, mtl -any, parsec -any, filepath -any, directory -any     main-is: Main.hs     buildable: True@@ -170,7 +170,7 @@ test-suite tests     build-depends: base >=4 && <5, containers -any, directory -any,                    filepath -any, mtl -any, parsec -any, purescript -any,-                   transformers -any, utf8-string -any, process -any+                   transformers -any, process -any     type: exitcode-stdio-1.0     main-is: Main.hs     buildable: True

@@ -49,6 +49,11 @@ moduleToCoreFn _ (A.Module{}) =   error "Module exports were not elaborated before moduleToCoreFn" +-- |+-- Find module names from qualified references to values. This is used to+-- ensure instances are imported from any module that is referenced by the+-- current module, not just from those that are imported explicitly (#667).+-- findQualModules :: [A.Declaration] -> [ModuleName] findQualModules decls =   let (f, _, _, _, _) = everythingOnValues (++) (const []) fqValues (const []) (const []) (const [])

@@ -209,15 +209,24 @@   match (JSInstanceOf val ty) = Just (val, ty)   match _ = Nothing -unary :: UnaryOperator -> String -> Operator PrinterState JS String-unary op str = Wrap match (++)+unary' :: UnaryOperator -> (JS -> String) -> Operator PrinterState JS String+unary' op mkStr = Wrap match (++)   where   match :: Pattern PrinterState JS (String, JS)   match = mkPattern match'     where-    match' (JSUnary op' val) | op' == op = Just (str, val)+    match' (JSUnary op' val) | op' == op = Just (mkStr val, val)     match' _ = Nothing +unary :: UnaryOperator -> String -> Operator PrinterState JS String+unary op str = unary' op (const str)++negateOperator :: Operator PrinterState JS String+negateOperator = unary' Negate (\v -> if isNegate v then "- " else "-")+  where+  isNegate (JSUnary Negate _) = True+  isNegate _ = False+ binary :: BinaryOperator -> String -> Operator PrinterState JS String binary op str = AssocL match (\v1 v2 -> v1 ++ " " ++ str ++ " " ++ v2)   where@@ -271,13 +280,13 @@                   , [ AssocR instanceOf $ \v1 v2 -> v1 ++ " instanceof " ++ v2 ]                   , [ unary     Not                  "!" ]                   , [ unary     BitwiseNot           "~" ]-                  , [ unary     Negate               "-" ]+                  , [ negateOperator ]                   , [ unary     Positive             "+" ]-                  , [ binary    Multiply             "*" ]-                  , [ binary    Divide               "/" ]-                  , [ binary    Modulus              "%" ]-                  , [ binary    Add                  "+" ]-                  , [ binary    Subtract             "-" ]+                  , [ binary    Multiply             "*"+                    , binary    Divide               "/"+                    , binary    Modulus              "%" ]+                  , [ binary    Add                  "+"+                    , binary    Subtract             "-" ]                   , [ binary    ShiftLeft            "<<" ]                   , [ binary    ShiftRight           ">>" ]                   , [ binary    ZeroFillShiftRight   ">>>" ]

@@ -58,8 +58,6 @@   where   (f', _, _) = everywhereOnValues id go id -  go (UnaryMinus (NumericLiteral (Left n))) = NumericLiteral (Left $ negate n)-  go (UnaryMinus (NumericLiteral (Right n))) = NumericLiteral (Right $ negate n)   go (UnaryMinus val) = App (Var (Qualified (Just (ModuleName [ProperName C.prelude])) (Ident C.negate))) val   go other = other 

@@ -472,7 +472,8 @@   a =?= tyArray   array <- ArrayLiteral <$> forM vals (`check` ty)   return $ TypedValue True array t-check' (Abs (Left arg) ret) ty@(TypeApp (TypeApp t argTy) retTy) | t == tyFunction = do+check' (Abs (Left arg) ret) ty@(TypeApp (TypeApp t argTy) retTy) = do+  t =?= tyFunction   Just moduleName <- checkCurrentModule <$> get   ret' <- makeBindingGroupVisible $ bindLocalVariables moduleName [(arg, argTy, Defined)] $ check ret retTy   return $ TypedValue True (Abs (Left arg) ret') ty

@@ -28,11 +28,10 @@ import System.FilePath (pathSeparator) import System.Directory (getCurrentDirectory, getTemporaryDirectory, getDirectoryContents, findExecutable) import Text.Parsec (ParseError)-import qualified System.IO.UTF8 as U  readInput :: [FilePath] -> IO [(FilePath, String)] readInput inputFiles = forM inputFiles $ \inputFile -> do-  text <- U.readFile inputFile+  text <- readFile inputFile   return (inputFile, text)  loadPrelude :: Either String (String, String, P.Environment)