Update build, fix warnings

Author: garyb

.travis.yml

@@ -1,7 +1,7 @@
 language: node_js
-sudo: required
 dist: trusty
-node_js: 5
+sudo: required
+node_js: 6
 env:
   - PATH=$HOME/purescript:$PATH
 install:
@@ -11,14 +11,13 @@ install:
   - chmod a+x $HOME/purescript
   - npm install -g bower
   - npm install
-  - bower install
 script:
-  - npm run build
+  - bower install --production
+  - npm run -s build
+  - bower install
+  - npm -s test
 after_success:
 - >-
   test $TRAVIS_TAG &&
-  psc-publish > .pursuit.json &&
-  curl -X POST http://pursuit.purescript.org/packages \
-    -d @.pursuit.json \
-    -H 'Accept: application/json' \
-    -H "Authorization: token ${GITHUB_TOKEN}"
+  echo $GITHUB_TOKEN | pulp login &&
+  echo y | pulp publish --no-push

bower.json

@@ -24,6 +24,7 @@
     "package.json"
   ],
   "dependencies": {
+    "purescript-arrays": "^1.0.0-rc.5",
     "purescript-distributive": "^1.0.0-rc.1",
     "purescript-lazy": "^1.0.0-rc.1",
     "purescript-tailrec": "^1.0.0-rc.1",

package.json

@@ -2,11 +2,12 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "pulp build",
+    "build": "pulp build --censor-lib --strict",
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^8.1.0",
+    "pulp": "^8.2.0",
+    "purescript-psa": "^0.3.8",
     "rimraf": "^2.5.0"
   }
 }

src/Control/Comonad/Env.purs

@@ -1,10 +1,19 @@
 -- | This module defines the `Env` comonad.
 
-module Control.Comonad.Env where
+module Control.Comonad.Env
+  ( Env
+  , runEnv
+  , withEnv
+  , mapEnv
+  , env
+  , module Control.Comonad.Env.Class
+  , module Control.Comonad.Env.Trans
+  ) where
 
 import Prelude
 
-import Control.Comonad.Env.Trans (EnvT(..), withEnvT)
+import Control.Comonad.Env.Class (class ComonadEnv, ask, asks, local)
+import Control.Comonad.Env.Trans (EnvT(..), mapEnvT, runEnvT, withEnvT)
 
 import Data.Identity (Identity(..), runIdentity)
 import Data.Tuple (Tuple(..))

src/Control/Comonad/Store.purs

@@ -1,10 +1,17 @@
 -- | This module defines the `Store` comonad.
 
-module Control.Comonad.Store where
+module Control.Comonad.Store
+  ( Store
+  , runStore
+  , store
+  , module Control.Comonad.Store.Class
+  , module Control.Comonad.Store.Trans
+  ) where
 
 import Prelude
 
-import Control.Comonad.Store.Trans (StoreT(..))
+import Control.Comonad.Store.Class (class ComonadStore, experiment, peek, peeks, pos, seek, seeks)
+import Control.Comonad.Store.Trans (StoreT(..), runStoreT)
 
 import Data.Identity (Identity(..), runIdentity)
 import Data.Tuple (Tuple(..), swap)

src/Control/Comonad/Traced.purs

@@ -1,10 +1,17 @@
 -- | This module defines the `Traced` comonad.
 
-module Control.Comonad.Traced where
+module Control.Comonad.Traced
+  ( Traced
+  , runTraced
+  , traced
+  , module Control.Comonad.Traced.Class
+  , module Control.Comonad.Traced.Trans
+  ) where
 
 import Prelude
 
-import Control.Comonad.Traced.Trans (TracedT(..))
+import Control.Comonad.Traced.Class (class ComonadTraced, censor, listen, listens, track, tracks)
+import Control.Comonad.Traced.Trans (TracedT(..), runTracedT)
 
 import Data.Identity (Identity(..), runIdentity)
 

src/Control/Monad/Cont.purs

@@ -4,14 +4,16 @@ module Control.Monad.Cont
   ( Cont
   , cont
   , runCont
-  , module X
+  , module Control.Monad.Cont.Trans
+  , module Control.Monad.Cont.Class
   ) where
 
 import Prelude
 
-import Control.Monad.Cont.Trans (ContT(ContT), mapContT, runContT, withContT)
-import Control.Monad.Cont.Class (callCC) as X
-import Data.Identity (Identity(Identity), runIdentity)
+import Control.Monad.Cont.Class (class MonadCont, callCC)
+import Control.Monad.Cont.Trans (class MonadTrans, ContT(..), lift, mapContT, runContT, withContT)
+
+import Data.Identity (Identity(..), runIdentity)
 
 -- | The `Cont` monad is a synonym for the `ContT` monad transformer applied to
 -- | the `Identity` monad.

src/Control/Monad/Cont/Trans.purs

@@ -10,8 +10,8 @@ import Prelude
 
 import Control.Monad.Cont.Class (class MonadCont, callCC)
 import Control.Monad.Eff.Class (class MonadEff, liftEff)
-import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
-import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
+import Control.Monad.Reader.Class (class MonadReader, ask, local)
+import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans (class MonadTrans, lift)
 
 -- | The CPS monad transformer.

src/Control/Monad/Except.purs

@@ -5,14 +5,13 @@ module Control.Monad.Except
   , mapExcept
   , withExcept
   , module Control.Monad.Error.Class
-  , module Trans
+  , module Control.Monad.Except.Trans
   ) where
 
 import Prelude
 
-import Control.Monad.Error.Class (class MonadError, throwError, catchError, catchJust)
-import Control.Monad.Except.Trans (except) as Trans
-import Control.Monad.Except.Trans (ExceptT(..), withExceptT, runExceptT, mapExceptT)
+import Control.Monad.Error.Class (class MonadError, catchError, catchJust, throwError)
+import Control.Monad.Except.Trans (class MonadTrans, ExceptT(..), except, lift, mapExceptT, runExceptT, withExceptT)
 
 import Data.Either (Either)
 import Data.Identity (Identity(..), runIdentity)

src/Control/Monad/List/Trans.purs

@@ -92,8 +92,8 @@ stepMap f (ListT l) = ListT $ f <$> l
 -- | Append one list to another.
 concat :: forall f a. Applicative f => ListT f a -> ListT f a -> ListT f a
 concat x y = stepMap f x where
-  f (Yield a s) = Yield a ((<> y) <$> s)
-  f (Skip s)    = Skip ((<> y) <$> s)
+  f (Yield a s) = Yield a ((_ <> y) <$> s)
+  f (Skip s)    = Skip ((_ <> y) <$> s)
   f Done        = Skip (defer $ const y)
 
 -- | Create a list with one element.
@@ -102,7 +102,7 @@ singleton a = prepend a nil
 
 -- | Lift a computation from the base functor.
 fromEffect :: forall f a. Applicative f => f a -> ListT f a
-fromEffect fa = ListT $ (`Yield` (defer $ \_ -> nil)) <$> fa
+fromEffect fa = ListT $ (flip Yield (defer $ \_ -> nil)) <$> fa
 
 -- | Lift a computation from the base monad.
 wrapEffect :: forall f a. Functor f => f (ListT f a) -> ListT f a
@@ -265,8 +265,8 @@ instance bindListT :: Monad f => Bind (ListT f) where
     g (Yield a s) = Skip (h <$> s)
       where
       h s = f a <> (s >>= f)
-    g (Skip s)    = Skip ((>>= f) <$> s)
-    g Done        = Done
+    g (Skip s) = Skip ((_ >>= f) <$> s)
+    g Done = Done
 
 instance monadListT :: Monad f => Monad (ListT f)
 

src/Control/Monad/Maybe/Trans.purs

@@ -11,20 +11,19 @@ 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 MonadError, catchError, catchJust, throwError)
-import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
-import Control.Monad.Rec.Class (class MonadRec, forever, tailRec, tailRecM, tailRecM2, tailRecM3)
+import Control.Monad.Error.Class (class MonadError, catchError, throwError)
+import Control.Monad.Reader.Class (class MonadReader, local, ask)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM)
 import Control.Monad.RWS.Class (class MonadRWS)
-import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
+import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans (class MonadTrans, lift)
-import Control.Monad.Writer.Class (class MonadWriter, censor, listen, listens, pass, tell, writer)
+import Control.Monad.Writer.Class (class MonadWriter, pass, listen, writer)
 import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
 
 import Data.Either (Either(..))
 import Data.Maybe (Maybe(..))
-import Data.Monoid (class Monoid)
 import Data.Tuple (Tuple(..))
 
 -- | The `MaybeT` monad transformer.

src/Control/Monad/RWS.purs

@@ -8,13 +8,14 @@ module Control.Monad.RWS
   , execRWS
   , mapRWS
   , withRWS
-  , module X
+  , module Control.Monad.RWS.Class
+  , module Control.Monad.RWS.Trans
   ) where
 
 import Prelude
 
-import Control.Monad.RWS.Class as X
-import Control.Monad.RWS.Trans (RWST(..), RWSResult, runRWST, mapRWST, withRWST, execRWST, evalRWST)
+import Control.Monad.RWS.Class (class MonadRWS, class MonadReader, class MonadState, class MonadTrans, class MonadWriter, ask, censor, get, gets, lift, listen, listens, local, modify, pass, put, reader, state, tell, writer)
+import Control.Monad.RWS.Trans (class MonadTrans, RWSResult(..), RWST(..), evalRWST, execRWST, lift, mapRWST, runRWST, withRWST)
 
 import Data.Identity (Identity(..), runIdentity)
 import Data.Tuple (Tuple)

src/Control/Monad/RWS/Class.purs

@@ -8,14 +8,11 @@ module Control.Monad.RWS.Class
   , module Control.Monad.State.Class
   ) where
 
-import Prelude
-
 import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
 import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
 import Control.Monad.Trans (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter, censor, listen, listens, pass, tell, writer)
 
-import Data.Monoid (class Monoid)
 
 -- | `MonadRWS r w s` combines the operations and laws of the `MonadReader r`,
 -- | `MonadWriter w` and `MonadState s` type classes.

src/Control/Monad/Reader.purs

@@ -5,13 +5,14 @@ module Control.Monad.Reader
   , runReader
   , mapReader
   , withReader
-  , module X
+  , module Control.Monad.Reader.Class
+  , module Control.Monad.Reader.Trans
   ) where
 
 import Prelude
 
-import Control.Monad.Reader.Class (ask, local, reader) as X
-import Control.Monad.Reader.Trans (ReaderT(..), mapReaderT, withReaderT)
+import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
+import Control.Monad.Reader.Trans (class MonadTrans, ReaderT(..), lift, mapReaderT, runReaderT, withReaderT)
 
 import Data.Identity (Identity(..), runIdentity)
 

src/Control/Monad/Reader/Trans.purs

@@ -12,12 +12,12 @@ 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 MonadError, catchError, catchJust, throwError)
+import Control.Monad.Error.Class (class MonadError, catchError, throwError)
 import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
-import Control.Monad.Rec.Class (class MonadRec, forever, tailRec, tailRecM, tailRecM2, tailRecM3)
-import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM)
+import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans (class MonadTrans, lift)
-import Control.Monad.Writer.Class (class MonadWriter, censor, listen, listens, pass, tell, writer)
+import Control.Monad.Writer.Class (class MonadWriter, pass, listen, writer)
 import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus, empty)

src/Control/Monad/State.purs

@@ -7,16 +7,17 @@ module Control.Monad.State
   , execState
   , mapState
   , withState
-  , module X
+  , module Control.Monad.State.Class
+  , module Control.Monad.State.Trans
   ) where
 
 import Prelude
 
-import Control.Monad.State.Class (get, gets, put, modify) as X
-import Control.Monad.State.Trans (StateT(..), runStateT, withStateT, mapStateT)
+import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
+import Control.Monad.State.Trans (class MonadTrans, StateT(..), evalStateT, execStateT, lift, mapStateT, runStateT, withStateT)
 
 import Data.Identity (Identity(..), runIdentity)
-import Data.Tuple (Tuple(..), fst, snd)
+import Data.Tuple (Tuple(Tuple))
 
 -- | The `State` monad is a synonym for the `StateT` monad transformer, applied
 -- | to the `Identity` monad.

src/Control/Monad/State/Trans.purs

@@ -13,12 +13,12 @@ import Control.Alternative (class Alternative)
 import Control.Lazy (class Lazy)
 import Control.Monad.Cont.Class (class MonadCont, callCC)
 import Control.Monad.Eff.Class (class MonadEff, liftEff)
-import Control.Monad.Error.Class (class MonadError, catchError, catchJust, throwError)
-import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
-import Control.Monad.Rec.Class (class MonadRec, forever, tailRec, tailRecM, tailRecM2, tailRecM3)
+import Control.Monad.Error.Class (class MonadError, catchError, throwError)
+import Control.Monad.Reader.Class (class MonadReader, local, ask)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM)
 import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
 import Control.Monad.Trans (class MonadTrans, lift)
-import Control.Monad.Writer.Class (class MonadWriter, censor, listen, listens, pass, tell, writer)
+import Control.Monad.Writer.Class (class MonadWriter, pass, listen, writer)
 import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus, empty)

src/Control/Monad/Writer.purs

@@ -6,12 +6,13 @@ module Control.Monad.Writer
   , execWriter
   , mapWriter
   , module Control.Monad.Writer.Class
+  , module Control.Monad.Writer.Trans
   ) where
 
 import Prelude
 
 import Control.Monad.Writer.Class (class MonadWriter, censor, listen, listens, pass, tell, writer)
-import Control.Monad.Writer.Trans (WriterT, runWriterT, mapWriterT)
+import Control.Monad.Writer.Trans (class MonadTrans, WriterT(..), execWriterT, lift, mapWriterT, runWriterT)
 
 import Data.Identity (Identity(..), runIdentity)
 import Data.Tuple (Tuple, snd)

src/Control/Monad/Writer/Trans.purs

@@ -16,10 +16,10 @@ 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 MonadError, catchError, catchJust, throwError)
-import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
-import Control.Monad.Rec.Class (class MonadRec, forever, tailRec, tailRecM, tailRecM2, tailRecM3)
-import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
+import Control.Monad.Error.Class (class MonadError, catchError, throwError)
+import Control.Monad.Reader.Class (class MonadReader, ask, local)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM)
+import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter, censor, listen, listens, pass, tell, writer)
 import Control.MonadPlus (class MonadPlus)

test/Test/Main.purs

@@ -5,11 +5,18 @@ import Prelude
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE)
 
+import Example.Cont as Cont
+import Example.Reader as Reader
+import Example.State as State
+import Example.StateEff as StateEff
+import Example.Writer as Writer
+import Example.RWS as RWS
+
 main :: Eff (console :: CONSOLE) Unit
 main = do
-  Example.Cont.main
-  Example.Reader.main
-  Example.State.main
-  Example.StateEff.main
-  Example.Writer.main
-  Example.RWS.main
+  Cont.main
+  Reader.main
+  State.main
+  StateEff.main
+  Writer.main
+  RWS.main