Merge pull request #25 from purescript/compiler/0.12

 Updates for 0.12

Author: garyb

.gitignore

@@ -5,3 +5,4 @@
 /bower_components/
 /node_modules/
 /output/
+package-lock.json

LICENSE

@@ -1,20 +1,26 @@
-The MIT License (MIT)
+Copyright 2018 PureScript
 
-Copyright (c) 2014 PureScript
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

bower.json

@@ -6,8 +6,7 @@
     "Gary Burgess <gary.burgess@gmail.com>",
     "John A. De Goes <john@degoes.net>"
   ],
-  "description": "Call-by-need values",
-  "license": "MIT",
+  "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
     "url": "git://github.com/purescript/purescript-lazy.git"
@@ -21,6 +20,9 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-monoid": "^3.0.0"
+    "purescript-control": "^4.0.0",
+    "purescript-foldable-traversable": "^4.0.0",
+    "purescript-invariant": "^4.0.0",
+    "purescript-prelude": "^4.0.0"
   }
 }

package.json

@@ -5,9 +5,9 @@
     "build": "eslint src && pulp build -- --censor-lib --strict"
   },
   "devDependencies": {
-    "eslint": "^3.17.1",
-    "pulp": "^10.0.4",
-    "purescript-psa": "^0.5.0-rc.1",
-    "rimraf": "^2.6.1"
+    "eslint": "^4.19.1",
+    "pulp": "^12.2.0",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Data/Lazy.purs

@@ -5,10 +5,17 @@ import Prelude
 import Control.Comonad (class Comonad)
 import Control.Extend (class Extend)
 import Control.Lazy as CL
-
+import Data.Eq (class Eq1)
+import Data.Foldable (class Foldable, foldMap, foldl, foldr)
+import Data.FoldableWithIndex (class FoldableWithIndex)
 import Data.Functor.Invariant (class Invariant, imapF)
+import Data.FunctorWithIndex (class FunctorWithIndex)
 import Data.HeytingAlgebra (implies, ff, tt)
-import Data.Monoid (class Monoid, mempty)
+import Data.Ord (class Ord1)
+import Data.Semigroup.Foldable (class Foldable1, fold1Default)
+import Data.Semigroup.Traversable (class Traversable1)
+import Data.Traversable (class Traversable, traverse)
+import Data.TraversableWithIndex (class TraversableWithIndex)
 
 -- | `Lazy a` represents lazily-computed values of type `a`.
 -- |
@@ -44,14 +51,16 @@ instance euclideanRingLazy :: EuclideanRing a => EuclideanRing (Lazy a) where
   div a b = defer \_ -> force a / force b
   mod a b = defer \_ -> force a `mod` force b
 
-instance fieldLazy :: Field a => Field (Lazy a)
-
 instance eqLazy :: Eq a => Eq (Lazy a) where
   eq x y = (force x) == (force y)
 
+derive instance eq1Lazy :: Eq1 Lazy
+
 instance ordLazy :: Ord a => Ord (Lazy a) where
   compare x y = compare (force x) (force y)
 
+derive instance ord1Lazy :: Ord1 Lazy
+
 instance boundedLazy :: Bounded a => Bounded (Lazy a) where
   top = defer \_ -> top
   bottom = defer \_ -> bottom
@@ -75,6 +84,34 @@ instance booleanAlgebraLazy :: BooleanAlgebra a => BooleanAlgebra (Lazy a)
 instance functorLazy :: Functor Lazy where
   map f l = defer \_ -> f (force l)
 
+instance functorWithIndexLazy :: FunctorWithIndex Unit Lazy where
+  mapWithIndex f = map $ f unit
+
+instance foldableLazy :: Foldable Lazy where
+  foldr f z l = f (force l) z
+  foldl f z l = f z (force l)
+  foldMap f l = f (force l)
+
+instance foldableWithIndexLazy :: FoldableWithIndex Unit Lazy where
+  foldrWithIndex f = foldr $ f unit
+  foldlWithIndex f = foldl $ f unit
+  foldMapWithIndex f = foldMap $ f unit
+
+instance foldable1Lazy :: Foldable1 Lazy where
+  foldMap1 f l = f (force l)
+  fold1 = fold1Default
+
+instance traversableLazy :: Traversable Lazy where
+  traverse f l = defer <<< const <$> f (force l)
+  sequence l = defer <<< const <$> force l
+
+instance traversableWithIndexLazy :: TraversableWithIndex Unit Lazy where
+  traverseWithIndex f = traverse $ f unit
+
+instance traversable1Lazy :: Traversable1 Lazy where
+  traverse1 f l = defer <<< const <$> f (force l)
+  sequence1 l = defer <<< const <$> force l
+
 instance invariantLazy :: Invariant Lazy where
   imap = imapF