Merge pull request #109 from purescript/compiler/0.12

Updates for 0.12

Author: garyb

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

@@ -1,15 +1,14 @@
 {
   "name": "purescript-transformers",
   "homepage": "https://github.com/purescript/purescript-transformers",
-  "description": "PureScript monad and comonad transformers library",
   "authors": [
     "Gary Burgess <[email protected]>",
     "Hardy Jones <[email protected]>",
     "Eric Thul <[email protected]>",
     "Phil Freeman <[email protected]>",
     "Brian McKenna <[email protected]>"
   ],
-  "license": "MIT",
+  "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
     "url": "git://github.com/purescript/purescript-transformers.git"
@@ -24,12 +23,22 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^4.0.0",
-    "purescript-lazy": "^3.0.0",
-    "purescript-distributive": "^3.0.0",
-    "purescript-tuples": "^4.0.0"
+    "purescript-control": "^4.0.0",
+    "purescript-distributive": "^4.0.0",
+    "purescript-effect": "^2.0.0",
+    "purescript-either": "^4.0.0",
+    "purescript-foldable-traversable": "^4.0.0",
+    "purescript-identity": "^4.0.0",
+    "purescript-lazy": "^4.0.0",
+    "purescript-maybe": "^4.0.0",
+    "purescript-newtype": "^3.0.0",
+    "purescript-prelude": "^4.0.0",
+    "purescript-tailrec": "^4.0.0",
+    "purescript-tuples": "^5.0.0",
+    "purescript-unfoldable": "^4.0.0"
   },
   "devDependencies": {
-    "purescript-console": "^3.0.0"
+    "purescript-arrays": "^5.0.0",
+    "purescript-console": "^4.0.0"
   }
 }

package.json

@@ -6,8 +6,8 @@
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^11.0.0",
-    "purescript-psa": "^0.5.1",
-    "rimraf": "^2.6.1"
+    "pulp": "^12.2.0",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Control/Comonad/Store/Class.purs

@@ -10,9 +10,7 @@ import Control.Comonad.Store.Trans (StoreT(..))
 import Control.Comonad.Traced.Trans (TracedT)
 import Control.Comonad.Trans.Class (lower)
 import Control.Extend (duplicate)
-
 import Data.Tuple (Tuple(..))
-import Data.Monoid (class Monoid)
 
 -- | The `ComonadStore` type class represents those monads which support local position information via
 -- | `pos` and `peek`.

src/Control/Comonad/Traced/Class.purs

@@ -6,8 +6,6 @@ import Prelude
 
 import Control.Comonad (class Comonad, extract)
 import Control.Comonad.Traced.Trans (TracedT(..))
-
-import Data.Monoid (class Monoid)
 import Data.Tuple (Tuple(..))
 
 -- | The `ComonadTraced` type class represents those monads which support relative (monoidal)

src/Control/Comonad/Traced/Trans.purs

@@ -7,8 +7,6 @@ import Prelude
 import Control.Comonad (class Comonad, extract)
 import Control.Comonad.Trans.Class (class ComonadTrans)
 import Control.Extend (class Extend, (<<=))
-
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype)
 
 -- | The cowriter comonad transformer.

src/Control/Monad/Cont/Trans.purs

@@ -9,12 +9,11 @@ module Control.Monad.Cont.Trans
 import Prelude
 
 import Control.Monad.Cont.Class (class MonadCont, callCC)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local)
 import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
-
 import Data.Newtype (class Newtype)
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | The CPS monad transformer.
 -- |
@@ -55,8 +54,8 @@ instance monadContT :: Monad m => Monad (ContT r m)
 instance monadTransContT :: MonadTrans (ContT r) where
   lift m = ContT (\k -> m >>= k)
 
-instance monadEffContT :: MonadEff eff m => MonadEff eff (ContT r m) where
-  liftEff = lift <<< liftEff
+instance monadEffectContT :: MonadEffect m => MonadEffect (ContT r m) where
+  liftEffect = lift <<< liftEffect
 
 instance monadAskContT :: MonadAsk r1 m => MonadAsk r1 (ContT r m) where
   ask = lift ask

src/Control/Monad/Except/Trans.purs

@@ -11,7 +11,6 @@ import Prelude
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
 import Control.Monad.Cont.Class (class MonadCont, callCC)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadThrow, class MonadError, throwError, catchError)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local)
 import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
@@ -21,11 +20,10 @@ import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, lis
 import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
-
 import Data.Either (Either(..), either)
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..))
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | A monad transformer which adds exceptions to other monads, in the same way
 -- | as `Except`. As before, `e` is the type of exceptions, and `a` is the type
@@ -103,8 +101,8 @@ instance monadTransExceptT :: MonadTrans (ExceptT e) where
     a <- m
     pure $ Right a
 
-instance monadEffExceptT :: MonadEff eff m => MonadEff eff (ExceptT e m) where
-  liftEff = lift <<< liftEff
+instance monadEffectExceptT :: MonadEffect m => MonadEffect (ExceptT e m) where
+  liftEffect = lift <<< liftEffect
 
 instance monadContExceptT :: MonadCont m => MonadCont (ExceptT e m) where
   callCC f = ExceptT $ callCC \c ->
@@ -136,5 +134,5 @@ instance monadWriterExceptT :: MonadWriter w m => MonadWriter w (ExceptT e m) wh
   pass = mapExceptT \m -> pass do
     a <- m
     pure case a of
-      Left e -> Tuple (Left e) id
+      Left e -> Tuple (Left e) identity
       Right (Tuple r f) -> Tuple (Right r) f

src/Control/Monad/List/Trans.purs

@@ -40,19 +40,18 @@ import Prelude
 
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
+import Control.Monad.Rec.Class as MR
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.MonadPlus (class MonadPlus)
-import Control.Monad.Rec.Class as MR
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
-
 import Data.Lazy (Lazy, defer, force)
 import Data.Maybe (Maybe(..), fromMaybe)
-import Data.Monoid (class Monoid)
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..), fst, snd)
 import Data.Unfoldable (class Unfoldable)
+import Data.Unfoldable1 (class Unfoldable1)
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | The list monad transformer.
 -- |
@@ -139,7 +138,7 @@ iterate f a = unfold g a
 
 -- | Generate an infinite list by repeating a value.
 repeat :: forall f a. Monad f => a -> ListT f a
-repeat = iterate id
+repeat = iterate identity
 
 -- | Take a number of elements from the front of a list.
 take :: forall f a. Applicative f => Int -> ListT f a -> ListT f a
@@ -187,7 +186,7 @@ mapMaybe f = stepMap g where
 
 -- | Remove elements from a list which do not contain a value.
 catMaybes :: forall f a. Functor f => ListT f (Maybe a) -> ListT f a
-catMaybes = mapMaybe id
+catMaybes = mapMaybe identity
 
 -- | Perform the first step of a computation in the `ListT` monad.
 uncons :: forall f a. Monad f => ListT f a -> f (Maybe (Tuple a (ListT f a)))
@@ -284,8 +283,17 @@ instance functorListT :: Functor f => Functor (ListT f) where
 
 instance unfoldableListT :: Monad f => Unfoldable (ListT f) where
   unfoldr f b = go (f b)
-    where go Nothing = nil
-          go (Just (Tuple x y)) = cons (pure x) (defer \_ -> (go (f y)))
+    where
+      go = case _ of
+        Nothing -> nil
+        Just (Tuple x y) -> cons (pure x) (defer \_ -> (go (f y)))
+
+instance unfoldable1ListT :: Monad f => Unfoldable1 (ListT f) where
+  unfoldr1 f b = go (f b)
+    where
+      go = case _ of
+        Tuple x Nothing -> singleton x
+        Tuple x (Just y) -> cons (pure x) (defer \_ -> (go (f y)))
 
 instance applyListT :: Monad f => Apply (ListT f) where
   apply = ap
@@ -318,5 +326,5 @@ instance monadZeroListT :: Monad f => MonadZero (ListT f)
 
 instance monadPlusListT :: Monad f => MonadPlus (ListT f)
 
-instance monadEffListT :: MonadEff eff m => MonadEff eff (ListT m) where
-  liftEff = lift <<< liftEff
+instance monadEffectListT :: MonadEffect m => MonadEffect (ListT m) where
+  liftEffect = lift <<< liftEffect

src/Control/Monad/Maybe/Trans.purs

@@ -10,7 +10,6 @@ import Prelude
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
 import Control.Monad.Cont.Class (class MonadCont, callCC)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadThrow, class MonadError, catchError, throwError)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local)
 import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
@@ -20,10 +19,10 @@ import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, lis
 import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
-
 import Data.Maybe (Maybe(..))
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..))
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | The `MaybeT` monad transformer.
 -- |
@@ -87,8 +86,8 @@ instance monadRecMaybeT :: MonadRec m => MonadRec (MaybeT m) where
             Just (Loop a1) -> Loop a1
             Just (Done b) -> Done (Just b)
 
-instance monadEffMaybe :: MonadEff eff m => MonadEff eff (MaybeT m) where
-  liftEff = lift <<< liftEff
+instance monadEffectMaybe :: MonadEffect m => MonadEffect (MaybeT m) where
+  liftEffect = lift <<< liftEffect
 
 instance monadContMaybeT :: MonadCont m => MonadCont (MaybeT m) where
   callCC f =
@@ -120,5 +119,5 @@ instance monadWriterMaybeT :: MonadWriter w m => MonadWriter w (MaybeT m) where
   pass = mapMaybeT \m -> pass do
     a <- m
     pure case a of
-      Nothing -> Tuple Nothing id
+      Nothing -> Tuple Nothing identity
       Just (Tuple v f) -> Tuple (Just v) f