Remove unused imports, fix some warnings

Author: garyb

src/Data/List.purs

@@ -85,18 +85,18 @@ module Data.List
 
 import Prelude
 
-import Data.Maybe
+import Control.Alt (Alt, (<|>))
+import Control.Alternative (Alternative)
+import Control.Lazy (Lazy, defer)
+import Control.MonadPlus (MonadPlus)
+import Control.Plus (Plus)
+
+import Data.Foldable (Foldable, foldl, foldr, any)
+import Data.Maybe (Maybe(..))
+import Data.Monoid (Monoid, mempty)
+import Data.Traversable (Traversable, traverse, sequence)
 import Data.Tuple (Tuple(..))
-import Data.Monoid
-import Data.Foldable
 import Data.Unfoldable (Unfoldable, unfoldr)
-import Data.Traversable
-
-import Control.Alt
-import Control.Lazy
-import Control.Plus
-import Control.Alternative
-import Control.MonadPlus
 
 -- | A strict linked list.
 -- |

src/Data/List/Lazy.purs

@@ -92,19 +92,20 @@ module Data.List.Lazy
 
 import Prelude
 
-import Control.Alt
-import Control.Alternative
-import Control.MonadPlus
-import Control.Plus
-import Data.Foldable
-import Data.Lazy
-import Data.Maybe
-import Data.Monoid
-import Data.Traversable
-import Data.Tuple (Tuple(..), fst, snd)
+import Control.Alt (Alt)
+import Control.Alternative (Alternative)
+import Control.MonadPlus (MonadPlus)
+import Control.Plus (Plus)
+import qualified Control.Lazy as Z
+
+import Data.Foldable (Foldable, foldMap, foldl, foldr, any)
+import Data.Lazy (Lazy(), defer, force)
+import Data.Maybe (Maybe(..), isNothing)
+import Data.Monoid (Monoid, mempty)
+import Data.Traversable (Traversable, traverse, sequence)
+import Data.Tuple (Tuple(..))
 import Data.Unfoldable (Unfoldable, unfoldr)
 
-import qualified Control.Lazy as Z
 
 -- | A lazy linked list.
 newtype List a = List (Lazy (Step a))

src/Data/List/ZipList.purs

@@ -8,14 +8,14 @@ module Data.List.ZipList
 
 import Prelude
 
-import Data.Monoid
-import Data.List.Lazy
-import Data.Foldable
-import Data.Traversable
-
-import Control.Alt
-import Control.Plus
-import Control.Alternative
+import Control.Alt (Alt)
+import Control.Alternative (Alternative)
+import Control.Plus (Plus)
+
+import Data.Foldable (Foldable, foldMap, foldl, foldr)
+import Data.List.Lazy (List(), repeat, zipWith)
+import Data.Monoid (Monoid, mempty)
+import Data.Traversable (Traversable, traverse, sequence)
 
 -- | `ZipList` is a newtype around `List` which provides a zippy
 -- | `Applicative` instance.

test/Test/Data/List.purs

@@ -1,16 +1,17 @@
 module Test.Data.List (testList) where
 
 import Prelude
-import Control.Monad
-import Control.Monad.Eff.Console (log)
+import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Console (CONSOLE(), log)
 import Data.Foldable
 import Data.Monoid.Additive
 import Data.List
 import Data.Maybe (Maybe(..), isNothing)
 import Data.Maybe.Unsafe (fromJust)
 import Data.Tuple (Tuple(..))
-import Test.Assert (assert)
+import Test.Assert (ASSERT(), assert)
 
+testList :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit
 testList = do
 
   log "singleton should construct an list with a single value"

test/Test/Data/List/Lazy.purs

@@ -1,13 +1,15 @@
 module Test.Data.List.Lazy (testListLazy) where
 
 import Prelude
-import Control.Monad.Eff.Console (log)
+import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Console (CONSOLE(), log)
 import Data.List.Lazy
 import Data.Maybe (Maybe(..), isNothing)
 import Data.Maybe.Unsafe (fromJust)
 import Data.Tuple (Tuple(..))
-import Test.Assert (assert)
+import Test.Assert (ASSERT(), assert)
 
+testListLazy :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit
 testListLazy = do
 
   log "singleton should construct an list with a single value"

test/Test/Data/List/Unsafe.purs

@@ -1,12 +1,13 @@
 module Test.Data.List.Unsafe (testListUnsafe) where
 
 import Prelude
-import Control.Monad.Eff.Console (log)
+import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Console (CONSOLE(), log)
 import Data.List (List(..), toList)
 import Data.List.Unsafe
-import Data.Maybe (Maybe(..))
-import Test.Assert (assert, assertThrows)
+import Test.Assert (ASSERT(), assert, assertThrows)
 
+testListUnsafe :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit
 testListUnsafe = do
 
   log "head should return a Just-wrapped first value of a non-empty list"

test/Test/Main.purs

@@ -1,10 +1,14 @@
 module Test.Main where
 
 import Prelude
+import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Console (CONSOLE())
+import Test.Assert (ASSERT())
 import Test.Data.List
 import Test.Data.List.Lazy
 import Test.Data.List.Unsafe
 
+main :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit
 main = do
   testList
   testListLazy