Merge pull request #57 from telser/purescript-0.8-warnings

Fix warnings generated by purescript-0.8.0

Author: garyb

.travis.yml

@@ -1,7 +1,6 @@
 language: node_js
 sudo: false
-node_js:
-  - 0.10
+node_js: 5
 env:
   - PATH=$HOME/purescript:$PATH
 install:

src/Data/Map.purs

@@ -27,14 +27,14 @@ module Data.Map
   , size
   ) where
 
-import Prelude
+import Prelude (class Ord, class Show, class Functor, class Semigroup, class Eq, (<<<), const, pure, ($), otherwise, (<), (&&), (==), one, (+), map, zero, show, id, (<$>), (<*>), compare, Ordering(..), append)
 
-import Data.Foldable (foldl, foldMap, foldr, Foldable)
+import Data.Foldable (foldl, foldMap, foldr, class Foldable)
 import Data.List (List(..), length, nub)
 import Data.Maybe (Maybe(..), maybe, isJust)
 import Data.Maybe.Unsafe (unsafeThrow)
-import Data.Monoid (Monoid)
-import Data.Traversable (traverse, Traversable)
+import Data.Monoid (class Monoid)
+import Data.Traversable (traverse, class Traversable)
 import Data.Tuple (Tuple(..), uncurry)
 
 -- | `Map k v` represents maps from keys of type `k` to values of type `v`.
@@ -47,7 +47,7 @@ instance eqMap :: (Eq k, Eq v) => Eq (Map k v) where
   eq m1 m2 = toList m1 == toList m2
 
 instance showMap :: (Show k, Show v) => Show (Map k v) where
-  show m = "fromList " ++ show (toList m)
+  show m = "fromList " `append` show (toList m)
 
 instance ordMap :: (Ord k, Ord v) => Ord (Map k v) where
   compare m1 m2 = compare (toList m1) (toList m2)
@@ -76,18 +76,18 @@ instance traversableMap :: (Ord k) => Traversable (Map k) where
 showTree :: forall k v. (Show k, Show v) => Map k v -> String
 showTree Leaf = "Leaf"
 showTree (Two left k v right) =
-  "Two (" ++ showTree left ++
-  ") (" ++ show k ++
-  ") (" ++ show v ++
-  ") (" ++ showTree right ++ ")"
+  "Two (" `append` showTree left `append`
+  ") (" `append` show k `append`
+  ") (" `append` show v `append`
+  ") (" `append` showTree right `append` ")"
 showTree (Three left k1 v1 mid k2 v2 right) =
-  "Three (" ++ showTree left ++
-  ") (" ++ show k1 ++
-  ") (" ++ show v1 ++
-  ") (" ++ showTree mid ++
-  ") (" ++ show k2 ++
-  ") (" ++ show v2 ++
-  ") (" ++ showTree right ++ ")"
+  "Three (" `append` showTree left `append`
+  ") (" `append` show k1 `append`
+  ") (" `append` show v1 `append`
+  ") (" `append` showTree mid `append`
+  ") (" `append` show k2 `append`
+  ") (" `append` show v2 `append`
+  ") (" `append` showTree right `append` ")"
 
 -- | An empty map
 empty :: forall k v. Map k v
@@ -110,8 +110,8 @@ checkValid tree = length (nub (allHeights tree)) == one
   where
   allHeights :: Map k v -> List Int
   allHeights Leaf = pure zero
-  allHeights (Two left _ _ right) = map (\n -> n + one) (allHeights left ++ allHeights right)
-  allHeights (Three left _ _ mid _ _ right) = map (\n -> n + one) (allHeights left ++ allHeights mid ++ allHeights right)
+  allHeights (Two left _ _ right) = map (\n -> n + one) (allHeights left `append` allHeights right)
+  allHeights (Three left _ _ mid _ _ right) = map (\n -> n + one) (allHeights left `append` allHeights mid `append` allHeights right)
 
 -- | Lookup a value for the specified key
 lookup :: forall k v. (Ord k) => k -> Map k v -> Maybe v
@@ -288,8 +288,8 @@ fromFoldableWith f = foldl (\m (Tuple k v) -> alter (combine v) k m) empty where
 -- | Convert a map to a list of key/value pairs
 toList :: forall k v. Map k v -> List (Tuple k v)
 toList Leaf = Nil
-toList (Two left k v right) = toList left ++ pure (Tuple k v) ++ toList right
-toList (Three left k1 v1 mid k2 v2 right) = toList left ++ pure (Tuple k1 v1) ++ toList mid ++ pure (Tuple k2 v2) ++ toList right
+toList (Two left k v right) = toList left `append` pure (Tuple k v) `append` toList right
+toList (Three left k1 v1 mid k2 v2 right) = toList left `append` pure (Tuple k1 v1) `append` toList mid `append` pure (Tuple k2 v2) `append` toList right
 
 -- | Create a map from a list of key/value pairs
 fromList :: forall k v. (Ord k) => List (Tuple k v) -> Map k v
@@ -303,14 +303,14 @@ fromListWith = fromFoldableWith
 -- | Get a list of the keys contained in a map
 keys :: forall k v. Map k v -> List k
 keys Leaf = Nil
-keys (Two left k _ right) = keys left ++ pure k ++ keys right
-keys (Three left k1 _ mid k2 _ right) = keys left ++ pure k1 ++ keys mid ++ pure k2 ++ keys right
+keys (Two left k _ right) = keys left `append` pure k `append` keys right
+keys (Three left k1 _ mid k2 _ right) = keys left `append` pure k1 `append` keys mid `append` pure k2 `append` keys right
 
 -- | Get a list of the values contained in a map
 values :: forall k v. Map k v -> List v
 values Leaf = Nil
-values (Two left _ v right) = values left ++ pure v ++ values right
-values (Three left _ v1 mid _ v2 right) = values left ++ pure v1 ++ values mid ++ pure v2 ++ values right
+values (Two left _ v right) = values left `append` pure v `append` values right
+values (Three left _ v1 mid _ v2 right) = values left `append` pure v1 `append` values mid `append` pure v2 `append` values right
 
 -- | Compute the union of two maps, using the specified function
 -- | to combine values for duplicate keys.

src/Data/StrMap.purs

@@ -36,19 +36,19 @@ module Data.StrMap
   , runST
   ) where
 
-import Prelude
+import Prelude (class Semigroup, class Eq, class Show, class Monad, class Functor, (<>), (<<<), return, (>>=), bind, const, (==), show, (++), (&&), id, (<$>), map, pure, (<*>), (#))
 
 import Control.Monad.Eff (Eff(), runPure)
-import Data.Foldable (Foldable, foldl, foldr, for_)
+import Data.Foldable (class Foldable, foldl, foldr, for_)
 import Data.Function (Fn2(), runFn2, Fn4(), runFn4)
 import Data.Maybe (Maybe(..), maybe, fromMaybe)
-import Data.Monoid (Monoid, mempty)
-import Data.Traversable (Traversable, traverse)
+import Data.Monoid (class Monoid, mempty)
+import Data.Traversable (class Traversable, traverse)
 import Data.Tuple (Tuple(..), uncurry)
 
-import qualified Data.List as L
-import qualified Control.Monad.ST as ST
-import qualified Data.StrMap.ST as SM
+import Data.List as L
+import Control.Monad.ST as ST
+import Data.StrMap.ST as SM
 
 -- | `StrMap a` represents a map from `String`s to values of type `a`.
 foreign import data StrMap :: * -> *

src/Data/StrMap/ST.purs

@@ -10,8 +10,6 @@ module Data.StrMap.ST
   , delete
   ) where
 
-import Prelude
-
 import Control.Monad.Eff (Eff())
 import Control.Monad.ST (ST())
 import Data.Maybe (Maybe(..))

src/Data/StrMap/ST/Unsafe.purs

@@ -2,8 +2,6 @@ module Data.StrMap.ST.Unsafe
   ( unsafeGet
   ) where
 
-import Prelude
-
 import Control.Monad.Eff (Eff())
 import Control.Monad.ST (ST())
 import Data.StrMap (StrMap())

src/Data/StrMap/Unsafe.purs

@@ -2,8 +2,6 @@ module Data.StrMap.Unsafe
   ( unsafeIndex
   ) where
 
-import Prelude
-
 import Data.StrMap (StrMap())
 
 -- | Unsafely get the value for a key in a map.

test/Test/Data/Map.purs

@@ -3,17 +3,20 @@ module Test.Data.Map where
 import Prelude
 
 import Control.Alt ((<|>))
-import Control.Monad.Eff.Console (log)
+import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Console (log, CONSOLE())
+import Control.Monad.Eff.Exception (EXCEPTION())
+import Control.Monad.Eff.Random (RANDOM())
 import Data.Foldable (foldl, for_)
 import Data.Function (on)
-import Data.List (List(..), groupBy, length, nubBy, sortBy, singleton, toList)
+import Data.List (List(..), groupBy, length, nubBy, sortBy, singleton)
 import Data.Maybe (Maybe(..), fromMaybe)
 import Data.Maybe.Unsafe (unsafeThrow)
 import Data.Tuple (Tuple(..), fst)
 import Test.QuickCheck ((<?>), quickCheck, quickCheck')
-import Test.QuickCheck.Arbitrary (Arbitrary, arbitrary)
+import Test.QuickCheck.Arbitrary (class Arbitrary, arbitrary)
 
-import qualified Data.Map as M
+import Data.Map as M
 
 newtype TestMap k v = TestMap (M.Map k v)
 
@@ -107,6 +110,14 @@ smallKey k = k
 number :: Int -> Int
 number n = n
 
+mapTests :: forall t.
+      Eff
+        ( console :: CONSOLE
+        , random :: RANDOM
+        , err :: EXCEPTION
+        | t
+        )
+        Unit
 mapTests = do
 
   -- Data.Map
@@ -181,7 +192,7 @@ mapTests = do
                        in f (f arr) == f (arr :: List (Tuple SmallKey Int)) <?> show arr
 
   log "fromList . toList = id"
-  quickCheck $ \(TestMap m) -> let f m = M.fromList (M.toList m) in
+  quickCheck $ \(TestMap m) -> let f m' = M.fromList (M.toList m') in
                      M.toList (f m) == M.toList (m :: M.Map SmallKey Int) <?> show m
 
   log "fromListWith const = fromList"

test/Test/Data/StrMap.purs

@@ -8,11 +8,13 @@ import Data.Function (on)
 import Data.Maybe (Maybe(..))
 import Data.Maybe.Unsafe (unsafeThrow)
 import Data.Tuple (Tuple(..), fst)
-import Control.Monad.Eff.Console (log)
+import Control.Monad.Eff(Eff())
+import Control.Monad.Eff.Console (log, CONSOLE())
+import Control.Monad.Eff.Exception (EXCEPTION())
+import Control.Monad.Eff.Random (RANDOM())
 import Test.QuickCheck ((<?>), quickCheck, quickCheck')
-import Test.QuickCheck.Arbitrary (Arbitrary, arbitrary)
-import qualified Data.String as S
-import qualified Data.StrMap as M
+import Test.QuickCheck.Arbitrary (class Arbitrary, arbitrary)
+import Data.StrMap as M
 
 newtype TestStrMap v = TestStrMap (M.StrMap v)
 
@@ -45,6 +47,14 @@ runInstructions instrs t0 = foldl step t0 instrs
 number :: Int -> Int
 number n = n
 
+strMapTests :: forall t.
+        Eff
+          ( console :: CONSOLE
+          , random :: RANDOM
+          , err :: EXCEPTION
+          | t
+          )
+          Unit
 strMapTests = do
   log "Test inserting into empty tree"
   quickCheck $ \k v -> M.lookup k (M.insert k v M.empty) == Just (number v)
@@ -110,7 +120,7 @@ strMapTests = do
 
   log "fromList . toList = id"
   quickCheck $ \(TestStrMap m) ->
-    let f m = M.fromList (M.toList m) in
+    let f m1 = M.fromList (M.toList m1) in
     M.toList (f m) == M.toList (m :: M.StrMap Int) <?> show m
 
   log "fromListWith const = fromList"

test/Test/Main.purs

@@ -2,11 +2,22 @@ module Test.Main where
 
 import Prelude
 
-import Control.Monad.Eff.Console (log)
+import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Console (log, CONSOLE())
+import Control.Monad.Eff.Exception (EXCEPTION())
+import Control.Monad.Eff.Random (RANDOM())
 
 import Test.Data.Map (mapTests)
 import Test.Data.StrMap (strMapTests)
 
+main :: forall t.
+      Eff
+        ( console :: CONSOLE
+        , random :: RANDOM
+        , err :: EXCEPTION
+        | t
+        )
+        Unit
 main = do
   log "Running Map tests"
   mapTests