updates for 0.12

Author: justinwoo

bower.json

@@ -18,15 +18,15 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-foldable-traversable": "^3.4.0",
-    "purescript-identity": "^3.1.0",
-    "purescript-arrays": "^4.1.2",
-    "purescript-either": "^3.1.0",
-    "purescript-lists": "^4.9.0",
-    "purescript-maps": "^3.4.0"
+    "purescript-foldable-traversable": "purescript/purescript-foldable-traversable#compiler/0.12",
+    "purescript-identity": "purescript/purescript-identity#compiler/0.12",
+    "purescript-arrays": "purescript/purescript-arrays#compiler/0.12",
+    "purescript-either": "purescript/purescript-either#compiler/0.12",
+    "purescript-lists": "purescript/purescript-lists#compiler/0.12",
+    "purescript-ordered-collections": "purescript-ordered-collections#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-assert": "^3.0.0",
-    "purescript-console": "^3.0.0"
+    "purescript-assert": "purescript/purescript-assert#compiler/0.12",
+    "purescript-console": "purescript-console#compiler/0.12"
   }
 }

src/Data/Filterable.purs

@@ -42,16 +42,16 @@ import Prelude (const, class Ord)
 -- | - `filter` - filter a data structure based on a boolean.
 -- |
 -- | Laws:
--- | - Functor Relation: `filterMap id ≡ compact`
--- | - Functor Identity: `filterMap Just ≡ id`
+-- | - Functor Relation: `filterMap identity ≡ compact`
+-- | - Functor Identity: `filterMap Just ≡ identity`
 -- | - Kleisli Composition: `filterMap (l <=< r) ≡ filterMap l <<< filterMap r`
 -- |
 -- | - `filter ≡ filterMap <<< maybeBool`
 -- | - `filterMap p ≡ filter (isJust <<< p)`
 -- |
--- | - Functor Relation: `partitionMap id ≡ separate`
--- | - Functor Identity 1: `_.right <<< partitionMap Right ≡ id`
--- | - Functor Identity 2: `_.left <<< partitionMap Left ≡ id`
+-- | - Functor Relation: `partitionMap identity ≡ separate`
+-- | - Functor Identity 1: `_.right <<< partitionMap Right ≡ identity`
+-- | - Functor Identity 2: `_.left <<< partitionMap Left ≡ identity`
 -- |
 -- | - `f <<< partition ≡ partitionMap <<< eitherBool` where `f = \{ no, yes } -> { left: no, right: yes }`
 -- | - `f <<< partitionMap p ≡ partition (isRight <<< p)` where `f = \{ left, right } -> { no: left, yes: right}`

src/Data/Witherable.purs

@@ -13,7 +13,7 @@ module Data.Witherable
   ) where
 
 import Control.Applicative (class Applicative, pure)
-import Control.Category ((<<<), id)
+import Control.Category ((<<<), identity)
 import Data.Compactable (compact, separate)
 import Data.Either (Either(..))
 import Data.Filterable (class Filterable)
@@ -89,12 +89,12 @@ traverseByWither f = wither (map Just <<< f)
 -- | Partition between `Left` and `Right` values - with effects in `m`.
 wilted :: forall t m l r. Witherable t => Applicative m =>
   t (m (Either l r)) -> m { left :: t l, right :: t r }
-wilted = wilt id
+wilted = wilt identity
 
 -- | Filter out all the `Nothing` values - with effects in `m`.
 withered :: forall t m x. Witherable t => Applicative m =>
   t (m (Maybe x)) -> m (t x)
-withered = wither id
+withered = wither identity
 
 instance witherableArray :: Witherable Array where
   wilt = wiltDefault

test/Main.purs

@@ -2,8 +2,8 @@ module Test.Main where
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 import Data.Compactable (compact, separate)
 import Data.Either (Either(..))
 import Data.Filterable (filter, filterMap, partition, partitionMap)
@@ -13,7 +13,7 @@ import Data.Map (fromFoldable) as Map
 import Data.Maybe (Maybe(..))
 import Data.Tuple.Nested ((/\))
 import Data.Witherable (wilt, wither)
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
 testEqNoYes :: ∀ a. (Ord a) => { no :: a, yes :: a } -> { no :: a, yes :: a } -> Boolean
 testEqNoYes { no: n1, yes: y1 } { no: n2, yes: y2 } =
@@ -23,7 +23,7 @@ testEqLeftRight :: ∀ a. (Ord a) => { left :: a, right :: a } -> { left :: a, r
 testEqLeftRight { left: l1, right: r1 } { left: l2, right: r2 } =
     l1 == l2 && r1 == r2
 
-testCompactable :: Eff (console :: CONSOLE, assert :: ASSERT) Unit
+testCompactable :: Effect Unit
 testCompactable = do
   log "Test compactableMaybe instance" *> do
     let parts1 = separate $ Just ((Left 1) :: Either Int Int)
@@ -84,7 +84,7 @@ testCompactable = do
     assert $ parts.left == comparisonMapOdds
     assert $ parts.right == comparisonMapEvens
 
-testFilterable :: Eff (console :: CONSOLE, assert :: ASSERT) Unit
+testFilterable :: Effect Unit
 testFilterable = do
   log "Test filterableMaybe instance" *> do
     assert $ filterMap pred (Just 6) == Just 60
@@ -120,7 +120,7 @@ testFilterable = do
   where
     pred x = if x > 5 then Just (x * 10) else Nothing
 
-testWitherable :: Eff (console :: CONSOLE, assert :: ASSERT) Unit
+testWitherable :: Effect Unit
 testWitherable = do
    log "Test witherableMaybe instance" *> do
      assert $ map _.right (wilt predE (Just 6)) == Identity (Just 60)
@@ -173,7 +173,7 @@ testWitherable = do
      predM x = if x > 5 then Identity (Just (x * 10)) else Identity Nothing
      predE x = if x > 5 then Identity (Right (x * 10)) else Identity (Left x)
 
-main :: Eff (console :: CONSOLE, assert :: ASSERT) Unit
+main :: Effect Unit
 main = do
   testCompactable
   testFilterable