Merge pull request #30 from purescript/updates

Updates

Author: paf31

README.md

@@ -238,7 +238,7 @@ Apply a function to the values in a map
 #### `size`
 
 ``` purescript
-size :: forall k v. Map k v -> Number
+size :: forall k v. Map k v -> Int
 ```
 
 Calculate the number of key/value pairs in a map
@@ -247,7 +247,7 @@ Calculate the number of key/value pairs in a map
 ## Module Data.StrMap
 
 
-This module defines a type of native Javascript maps which 
+This module defines a type of native Javascript maps which
 require the keys to be strings.
 
 To maximize performance, Javascript objects are not wrapped,
@@ -283,7 +283,7 @@ Convert a mutable map into an immutable map
 runST :: forall a r. (forall h. Eff (st :: ST.ST h | r) (SM.STStrMap h a)) -> Eff r (StrMap a)
 ```
 
-Freeze a mutable map, creating an immutable map. Use this function as you would use 
+Freeze a mutable map, creating an immutable map. Use this function as you would use
 `Prelude.runST` to freeze a mutable reference.
 
 The rank-2 type prevents the map from escaping the scope of `runST`.
@@ -503,7 +503,7 @@ Get an array of the values in a map
 union :: forall a. StrMap a -> StrMap a -> StrMap a
 ```
 
-Compute the union of two maps, preferring the first map in the case of 
+Compute the union of two maps, preferring the first map in the case of
 duplicate keys.
 
 #### `unions`

bower.json

@@ -22,14 +22,18 @@
     "package.json"
   ],
   "devDependencies": {
-    "purescript-quickcheck": "~0.5.0"
+    "purescript-quickcheck": "~0.6.0"
   },
   "dependencies": {
-    "purescript-arrays": "~0.3.0",
-    "purescript-foldable-traversable": "~0.3.0",
-    "purescript-strings": "~0.4.2",
-    "purescript-math": "~0.1.0",
-    "purescript-maybe": "~0.2.1",
-    "purescript-tuples": "~0.3.0"
+    "purescript-arrays": "~0.4.0",
+    "purescript-foldable-traversable": "~0.4.0",
+    "purescript-strings": "~0.5.0",
+    "purescript-math": "~0.1.1",
+    "purescript-maybe": "~0.3.0",
+    "purescript-tuples": "~0.4.0",
+    "purescript-integers": "~0.2.0",
+    "purescript-prelude": "~0.1.0",
+    "purescript-eff": "~0.1.0",
+    "purescript-st": "~0.1.0"
   }
 }

src/Data/Map.purs

@@ -2,36 +2,37 @@
 -- | <http://www.cs.princeton.edu/~dpw/courses/cos326-12/ass/2-3-trees.pdf>
 
 module Data.Map
-  ( Map(),
-    showTree,
-    empty,
-    isEmpty,
-    singleton,
-    checkValid,
-    insert,
-    lookup,
-    toList,
-    fromList,
-    fromListWith,
-    delete,
-    member,
-    alter,
-    update,
-    keys,
-    values,
-    union,
-    unionWith,
-    unions,
-    map,
-    size
+  ( Map()
+  , showTree
+  , empty
+  , isEmpty
+  , singleton
+  , checkValid
+  , insert
+  , lookup
+  , toList
+  , fromList
+  , fromListWith
+  , delete
+  , member
+  , alter
+  , update
+  , keys
+  , values
+  , union
+  , unionWith
+  , unions
+  , map
+  , size
   ) where
 
-import qualified Data.Array as A
-import Data.Maybe
-import Data.Tuple
-import Data.Monoid (Monoid)
 import Data.Foldable (foldl, foldMap, foldr, Foldable)
+import Data.Int (Int())
+import Data.Maybe (Maybe(..), maybe, isJust)
+import Data.Monoid (Monoid)
 import Data.Traversable (traverse, Traversable)
+import Data.Tuple (Tuple(..), uncurry)
+import qualified Data.Array as A
 
 -- | `Map k v` represents maps from keys of type `k` to values of type `v`.
 data Map k v
@@ -103,12 +104,12 @@ singleton k v = Two Leaf k v Leaf
 -- |
 -- | This function is provided for internal use.
 checkValid :: forall k v. Map k v -> Boolean
-checkValid tree = A.length (A.nub (allHeights tree)) == 1
+checkValid tree = A.length (A.nub (allHeights tree)) == one
   where
-  allHeights :: forall k v. Map k v -> [Number]
-  allHeights Leaf = [0]
-  allHeights (Two left _ _ right) = A.map (\n -> n + 1) (allHeights left ++ allHeights right)
-  allHeights (Three left _ _ mid _ _ right) = A.map (\n -> n + 1) (allHeights left ++ allHeights mid ++ allHeights right)
+  allHeights :: forall k v. Map k v -> [Int]
+  allHeights Leaf = [zero]
+  allHeights (Two left _ _ right) = A.map (\n -> n + one) (allHeights left ++ allHeights right)
+  allHeights (Three left _ _ mid _ _ right) = A.map (\n -> n + one) (allHeights left ++ allHeights mid ++ allHeights right)
 
 -- | Lookup a value for the specified key
 lookup :: forall k v. (Ord k) => k -> Map k v -> Maybe v
@@ -172,17 +173,17 @@ delete = down []
   where
   down :: forall k v. (Ord k) => [TreeContext k v] -> k -> Map k v -> Map k v
   down ctx _ Leaf = fromZipper ctx Leaf
-  down ctx k (Two Leaf k1 _ Leaf) 
+  down ctx k (Two Leaf k1 _ Leaf)
     | k == k1 = up ctx Leaf
-  down ctx k (Two left k1 v1 right) 
+  down ctx k (Two left k1 v1 right)
     | k == k1   = let max = maxNode left
                     in removeMaxNode (TwoLeft max.key max.value right : ctx) left
     | k < k1    = down (TwoLeft k1 v1 right : ctx) k left
     | otherwise = down (TwoRight left k1 v1 : ctx) k right
-  down ctx k (Three Leaf k1 v1 Leaf k2 v2 Leaf) 
+  down ctx k (Three Leaf k1 v1 Leaf k2 v2 Leaf)
     | k == k1 = fromZipper ctx (Two Leaf k2 v2 Leaf)
     | k == k2 = fromZipper ctx (Two Leaf k1 v1 Leaf)
-  down ctx k (Three left k1 v1 mid k2 v2 right) 
+  down ctx k (Three left k1 v1 mid k2 v2 right)
     | k == k1 = let max = maxNode left
                   in removeMaxNode (ThreeLeft max.key max.value mid k2 v2 right : ctx) left
     | k == k2 = let max = maxNode mid
@@ -283,5 +284,5 @@ map :: forall k a b. (a -> b) -> Map k a -> Map k b
 map = (<$>)
 
 -- | Calculate the number of key/value pairs in a map
-size :: forall k v. Map k v -> Number
+size :: forall k v. Map k v -> Int
 size = A.length <<< values

src/Data/StrMap.purs

@@ -1,49 +1,47 @@
--- | This module defines a type of native Javascript maps which 
+-- | This module defines a type of native Javascript maps which
 -- | require the keys to be strings.
--- | 
+-- |
 -- | To maximize performance, Javascript objects are not wrapped,
 -- | and some native code is used even when it's not necessary.
 
 module Data.StrMap
-  ( StrMap(),
-    empty,
-    isEmpty,
-    size,
-    singleton,
-    insert,
-    lookup,
-    toList,
-    fromList,
-    fromListWith,
-    delete,
-    member,
-    alter,
-    update,
-    keys,
-    values,
-    union,
-    unions,
-    map,
-    isSubmap,
-    fold,
-    foldMap,
-    foldM,
-    foldMaybe,
-    all,
-
-    thawST,
-    freezeST,
-    runST
+  ( StrMap()
+  , empty
+  , isEmpty
+  , size
+  , singleton
+  , insert
+  , lookup
+  , toList
+  , fromList
+  , fromListWith
+  , delete
+  , member
+  , alter
+  , update
+  , keys
+  , values
+  , union
+  , unions
+  , map
+  , isSubmap
+  , fold
+  , foldMap
+  , foldM
+  , foldMaybe
+  , all
+  , thawST
+  , freezeST
+  , runST
   ) where
 
 import Control.Monad.Eff (Eff(), runPure)
 import Data.Foldable (Foldable, foldl, foldr, for_)
-import Data.Function
-import Data.Maybe
-import Data.Monoid
-import Data.Monoid.All
-import Data.Tuple
+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.Tuple (Tuple(..), uncurry)
 import qualified Control.Monad.ST as ST
 import qualified Data.Array as A
 import qualified Data.StrMap.ST as SM
@@ -83,9 +81,9 @@ thawST = _copyEff
 freezeST :: forall a h r. SM.STStrMap h a -> Eff (st :: ST.ST h | r) (StrMap a)
 freezeST = _copyEff
 
--- | Freeze a mutable map, creating an immutable map. Use this function as you would use 
+-- | Freeze a mutable map, creating an immutable map. Use this function as you would use
 -- | `Prelude.runST` to freeze a mutable reference.
--- | 
+-- |
 -- | The rank-2 type prevents the map from escaping the scope of `runST`.
 foreign import runST
   """
@@ -329,7 +327,7 @@ foreign import keys
 values :: forall a. StrMap a -> [a]
 values = _collect (\_ v -> v)
 
--- | Compute the union of two maps, preferring the first map in the case of 
+-- | Compute the union of two maps, preferring the first map in the case of
 -- | duplicate keys.
 union :: forall a. StrMap a -> StrMap a -> StrMap a
 union m = mutate (\s -> foldM SM.poke s m)

tests/Data/Map.purs

@@ -1,16 +1,15 @@
 module Tests.Data.Map where
 
-import Debug.Trace
-
 import Control.Alt ((<|>))
-import Data.Maybe
-import Data.Tuple
 import Data.Array (groupBy, map, length, nubBy, sortBy)
-import Data.Function (on)
 import Data.Foldable (foldl, for_)
-
-import Test.QuickCheck
-
+import Data.Function (on)
+import Data.Maybe (Maybe(..), fromMaybe)
+import Data.Int (fromNumber)
+import Data.Tuple (Tuple(..), fst)
+import Debug.Trace
+import Test.QuickCheck ((<?>), quickCheck, quickCheck')
+import Test.QuickCheck.Arbitrary (Arbitrary, arbitrary)
 import qualified Data.Map as M
 
 instance arbMap :: (Eq k, Ord k, Arbitrary k, Arbitrary v) => Arbitrary (M.Map k v) where
@@ -129,7 +128,7 @@ mapTests = do
     <?> ("k1: " ++ show k1 ++ ", v1: " ++ show v1 ++ ", k2: " ++ show k2 ++ ", v2: " ++ show v2)
 
   trace "Check balance property"
-  quickCheck' 5000 $ \instrs ->
+  quickCheck' (fromNumber 5000) $ \instrs ->
     let
       tree :: M.Map SmallKey Number
       tree = runInstructions instrs M.empty
@@ -142,7 +141,7 @@ mapTests = do
   quickCheck $ \k v -> M.lookup (k :: SmallKey) (M.singleton k (v :: Number)) == Just v
 
   trace "Random lookup"
-  quickCheck' 5000 $ \instrs k v ->
+  quickCheck' (fromNumber 5000) $ \instrs k v ->
     let
       tree :: M.Map SmallKey Number
       tree = M.insert k v (runInstructions instrs M.empty)

tests/Data/StrMap.purs

@@ -1,16 +1,15 @@
 module Tests.Data.StrMap where
 
-import Debug.Trace
-
-import Data.Maybe
-import Data.Tuple
-import qualified Data.String as S
 import Data.Array (groupBy, map, sortBy)
-import Data.Function (on)
 import Data.Foldable (foldl)
-
-import Test.QuickCheck
-
+import Data.Function (on)
+import Data.Maybe (Maybe(..))
+import Data.Int (fromNumber)
+import Data.Tuple (Tuple(..), fst, zip)
+import Debug.Trace
+import Test.QuickCheck ((<?>), quickCheck, quickCheck')
+import Test.QuickCheck.Arbitrary (Arbitrary, arbitrary)
+import qualified Data.String as S
 import qualified Data.StrMap as M
 
 instance arbStrMap :: (Arbitrary v) => Arbitrary (M.StrMap v) where
@@ -70,7 +69,7 @@ strMapTests = do
   quickCheck $ \k v -> M.lookup k (M.singleton k (v :: Number)) == Just v
 
   trace "Random lookup"
-  quickCheck' 5000 $ \instrs k v ->
+  quickCheck' (fromNumber 5000) $ \instrs k v ->
     let
       tree :: M.StrMap Number
       tree = M.insert k v (runInstructions instrs M.empty)