Merge branch 'compiler/0.12' into NonEmpty-Derive-Foldable1

Author: garyb

bower.json

@@ -20,17 +20,17 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-lazy": "^3.0.0",
-    "purescript-nonempty": "^4.2.0",
-    "purescript-tailrec": "^3.3.0",
-    "purescript-unfoldable": "^3.0.0",
-    "purescript-partial": "^1.0.0",
-    "purescript-foldable-traversable": "^3.4.0"
+    "purescript-lazy": "#compiler/0.12",
+    "purescript-nonempty": "#compiler/0.12",
+    "purescript-tailrec": "#compiler/0.12",
+    "purescript-unfoldable": "#compiler/0.12",
+    "purescript-partial": "#compiler/0.12",
+    "purescript-foldable-traversable": "#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-arrays": "^4.0.0",
-    "purescript-assert": "^3.0.0",
-    "purescript-console": "^3.0.0",
-    "purescript-math": "^2.0.0"
+    "purescript-arrays": "#compiler/0.12",
+    "purescript-assert": "#compiler/0.12",
+    "purescript-console": "#compiler/0.12",
+    "purescript-math": "#compiler/0.12"
   }
 }

package.json

@@ -3,11 +3,11 @@
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
     "build": "pulp build -- --censor-lib --strict",
-    "test": "pulp test"
+    "test": "pulp test --check-main-type Effect.Effect"
   },
   "devDependencies": {
-    "pulp": "^11.0.0",
-    "purescript-psa": "^0.5.1",
-    "rimraf": "^2.6.1"
+    "pulp": "^12.0.1",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Data/List.purs

@@ -372,7 +372,7 @@ reverse = go Nil
 -- |
 -- | Running time: `O(n)`, where `n` is the total number of elements.
 concat :: forall a. List (List a) -> List a
-concat = (_ >>= id)
+concat = (_ >>= identity)
 
 -- | Apply a function to each element in a list, and flatten the results
 -- | into a single, new list.
@@ -423,7 +423,7 @@ mapMaybe f = go Nil
 -- | Filter a list of optional values, keeping only the elements which contain
 -- | a value.
 catMaybes :: forall a. List (Maybe a) -> List a
-catMaybes = mapMaybe id
+catMaybes = mapMaybe identity
 
 
 -- | Apply a function to each element and its index in a list starting at 0.

src/Data/List/Lazy.purs

@@ -409,7 +409,7 @@ reverse xs = Z.defer \_ -> foldl (flip cons) nil xs
 -- |
 -- | Running time: `O(n)`, where `n` is the total number of elements.
 concat :: forall a. List (List a) -> List a
-concat = (_ >>= id)
+concat = (_ >>= identity)
 
 -- | Apply a function to each element in a list, and flatten the results
 -- | into a single, new list.
@@ -463,7 +463,7 @@ mapMaybe f = List <<< map go <<< unwrap
 -- | Filter a list of optional values, keeping only the elements which contain
 -- | a value.
 catMaybes :: forall a. List (Maybe a) -> List a
-catMaybes = mapMaybe id
+catMaybes = mapMaybe identity
 
 --------------------------------------------------------------------------------
 -- Sorting ---------------------------------------------------------------------
@@ -509,10 +509,11 @@ slice start end xs = take (end - start) (drop start xs)
 -- |
 -- | Running time: `O(n)` where `n` is the number of elements to take.
 take :: forall a. Int -> List a -> List a
-take n = List <<< map (go n) <<< unwrap
+take n = if n <= 0
+  then const nil
+  else List <<< map (go n) <<< unwrap
   where
   go :: Int -> Step a -> Step a
-  go i _ | i <= 0 = Nil
   go _ Nil = Nil
   go n' (Cons x xs) = Cons x (take (n' - 1) xs)
 

src/Data/List/Lazy/Types.purs

@@ -16,7 +16,6 @@ import Data.FoldableWithIndex (class FoldableWithIndex, foldlWithIndex, foldrWit
 import Data.FunctorWithIndex (class FunctorWithIndex)
 import Data.Lazy (Lazy, defer, force)
 import Data.Maybe (Maybe(..))
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype, unwrap)
 import Data.NonEmpty (NonEmpty, (:|))
 import Data.NonEmpty as NE
@@ -25,6 +24,7 @@ import Data.Traversable (class Traversable, traverse, sequence)
 import Data.TraversableWithIndex (class TraversableWithIndex)
 import Data.Tuple (Tuple(..), snd)
 import Data.Unfoldable (class Unfoldable)
+import Data.Unfoldable1 (class Unfoldable1)
 
 -- | A lazy linked list.
 newtype List a = List (Lazy (Step a))
@@ -141,6 +141,12 @@ instance foldableWithIndexList :: FoldableWithIndex Int List where
     snd <<< foldl (\(Tuple i b) a -> Tuple (i + 1) (f i b a)) (Tuple 0 acc)
   foldMapWithIndex f = foldlWithIndex (\i acc -> append acc <<< f i) mempty
 
+instance unfoldable1List :: Unfoldable1 List where
+  unfoldr1 = go where
+    go f b = Z.defer \_ -> case f b of
+      Tuple a (Just b') -> a : go f b'
+      Tuple a Nothing -> a : nil
+
 instance unfoldableList :: Unfoldable List where
   unfoldr = go where
     go f b = Z.defer \_ -> case f b of
@@ -151,7 +157,7 @@ instance traversableList :: Traversable List where
   traverse f =
     foldr (\a b -> cons <$> f a <*> b) (pure nil)
 
-  sequence = traverse id
+  sequence = traverse identity
 
 instance traversableWithIndexList :: TraversableWithIndex Int List where
   traverseWithIndex f =

src/Data/List/NonEmpty.purs

@@ -210,7 +210,7 @@ catMaybes :: forall a. NonEmptyList (Maybe a) -> L.List a
 catMaybes = lift L.catMaybes
 
 concat :: forall a. NonEmptyList (NonEmptyList a) -> NonEmptyList a
-concat = (_ >>= id)
+concat = (_ >>= identity)
 
 concatMap :: forall a b. (a -> NonEmptyList b) -> NonEmptyList a -> NonEmptyList b
 concatMap = flip bind

src/Data/List/Types.purs

@@ -15,7 +15,6 @@ import Data.Foldable (class Foldable, foldl, foldr, intercalate)
 import Data.FoldableWithIndex (class FoldableWithIndex, foldlWithIndex, foldrWithIndex)
 import Data.FunctorWithIndex (class FunctorWithIndex)
 import Data.Maybe (Maybe(..))
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype)
 import Data.NonEmpty (NonEmpty, (:|))
 import Data.NonEmpty as NE
@@ -26,6 +25,7 @@ import Data.Traversable (class Traversable, traverse)
 import Data.TraversableWithIndex (class TraversableWithIndex)
 import Data.Tuple (Tuple(..), snd)
 import Data.Unfoldable (class Unfoldable)
+import Data.Unfoldable1 (class Unfoldable1)
 
 data List a = Nil | Cons a (List a)
 
@@ -99,6 +99,13 @@ instance foldableWithIndexList :: FoldableWithIndex Int List where
     snd <<< foldl (\(Tuple i b) a -> Tuple (i + 1) (f i b a)) (Tuple 0 acc)
   foldMapWithIndex f = foldlWithIndex (\i acc -> append acc <<< f i) mempty
 
+instance unfoldable1List :: Unfoldable1 List where
+  unfoldr1 f b = go b Nil
+    where
+    go source memo = case f source of
+      Tuple one (Just rest) -> go rest (one : memo)
+      Tuple one Nothing -> foldl (flip (:)) Nil (one : memo)
+
 instance unfoldableList :: Unfoldable List where
   unfoldr f b = go b Nil
     where
@@ -108,7 +115,7 @@ instance unfoldableList :: Unfoldable List where
 
 instance traversableList :: Traversable List where
   traverse f = map (foldl (flip (:)) Nil) <<< foldl (\acc -> lift2 (flip (:)) acc <<< f) (pure Nil)
-  sequence = traverse id
+  sequence = traverse identity
 
 instance traversableWithIndexList :: TraversableWithIndex Int List where
   traverseWithIndex f =
@@ -210,4 +217,4 @@ instance traversable1NonEmptyList :: Traversable1 NonEmptyList where
   traverse1 f (NonEmptyList (a :| as)) =
     foldl (\acc -> lift2 (flip nelCons) acc <<< f) (pure <$> f a) as
       <#> case _ of NonEmptyList (x :| xs) → foldl (flip nelCons) (pure x) xs
-  sequence1 = traverse1 id
+  sequence1 = traverse1 identity

src/Data/List/ZipList.purs

@@ -6,12 +6,12 @@ module Data.List.ZipList
   ) where
 
 import Prelude
+import Prim.TypeError (class Fail, Text)
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
 import Control.Plus (class Plus)
 import Data.Foldable (class Foldable)
 import Data.List.Lazy (List, repeat, zipWith)
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype)
 import Data.Traversable (class Traversable)
 import Partial.Unsafe (unsafeCrashWith)
@@ -54,12 +54,12 @@ instance plusZipList :: Plus ZipList where
 instance alternativeZipList :: Alternative ZipList
 
 instance zipListIsNotBind
-  :: Fail """
+  :: Fail (Text """
     ZipList is not Bind. Any implementation would break the associativity law.
 
     Possible alternatives:
         Data.List.List
         Data.List.Lazy.List
-    """
+    """)
   => Bind ZipList where
     bind = unsafeCrashWith "bind: unreachable"

test/Test/Data/List.purs

@@ -2,8 +2,6 @@ module Test.Data.List (testList) where
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
 import Data.Foldable (foldMap, foldl)
 import Data.FoldableWithIndex (foldMapWithIndex, foldlWithIndex, foldrWithIndex)
 import Data.List (List(..), (..), stripPrefix, Pattern(..), length, range, foldM, unzip, zip, zipWithA, zipWith, intersectBy, intersect, (\\), deleteBy, delete, unionBy, union, nubBy, nub, groupBy, group', group, partition, span, dropWhile, drop, dropEnd, takeWhile, take, takeEnd, sortBy, sort, catMaybes, mapMaybe, filterM, filter, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, findLastIndex, findIndex, elemLastIndex, elemIndex, (!!), uncons, unsnoc, init, tail, last, head, insertBy, insert, snoc, null, singleton, fromFoldable, transpose, mapWithIndex, (:))
@@ -15,10 +13,13 @@ import Data.Traversable (traverse)
 import Data.TraversableWithIndex (traverseWithIndex)
 import Data.Tuple (Tuple(..))
 import Data.Unfoldable (replicate, replicateA, unfoldr)
+import Data.Unfoldable1 (unfoldr1)
+import Effect (Effect)
+import Effect.Console (log)
 import Partial.Unsafe (unsafePartial)
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testList :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit
+testList :: Effect Unit
 testList = do
   let l = fromFoldable
 
@@ -357,8 +358,11 @@ testList = do
   log "unfoldr should maintain order"
   assert $ (1..5) == unfoldr step 1
 
+  log "unfoldr1 should maintain order"
+  assert $ (1..5) == unfoldr1 step1 1
+
   log "map should maintain order"
-  assert $ (1..5) == map id (1..5)
+  assert $ (1..5) == map identity (1..5)
 
   log "transpose"
   assert $ transpose (l [l [1,2,3], l[4,5,6], l [7,8,9]]) ==
@@ -388,11 +392,13 @@ testList = do
   log "append should be stack-safe"
   void $ pure $ xs <> xs
 
-
 step :: Int -> Maybe (Tuple Int Int)
 step 6 = Nothing
 step n = Just (Tuple n (n + 1))
 
+step1 :: Int -> Tuple Int (Maybe Int)
+step1 n = Tuple n (if n >= 5 then Nothing else Just (n + 1))
+
 nil :: List Int
 nil = Nil
 

test/Test/Data/List/Lazy.purs

@@ -3,23 +3,25 @@ module Test.Data.List.Lazy (testListLazy) where
 import Prelude
 
 import Control.Lazy (defer)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
 import Data.FoldableWithIndex (foldMapWithIndex, foldlWithIndex, foldrWithIndex)
 import Data.FunctorWithIndex (mapWithIndex)
 import Data.Lazy as Z
-import Data.List.Lazy (List, nil, stripPrefix, Pattern(..), cons, foldl, foldr, foldMap, singleton, transpose, take, iterate, filter, uncons, foldM, foldrLazy, range, unzip, zip, length, zipWithA, replicate, repeat, zipWith, intersectBy, intersect, deleteBy, delete, unionBy, union, nubBy, nub, groupBy, group, partition, span, dropWhile, drop, takeWhile, slice, catMaybes, mapMaybe, filterM, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, findLastIndex, findIndex, elemLastIndex, elemIndex, init, tail, last, head, insertBy, insert, snoc, null, replicateM, fromFoldable, (:), (\\), (!!))
+import Data.List.Lazy (List, Pattern(..), alterAt, catMaybes, concat, concatMap, cons, delete, deleteAt, deleteBy, drop, dropWhile, elemIndex, elemLastIndex, filter, filterM, findIndex, findLastIndex, foldM, foldMap, foldl, foldr, foldrLazy, fromFoldable, group, groupBy, head, init, insert, insertAt, insertBy, intersect, intersectBy, iterate, last, length, mapMaybe, modifyAt, nil, nub, nubBy, null, partition, range, repeat, replicate, replicateM, reverse, singleton, slice, snoc, span, stripPrefix, tail, take, takeWhile, transpose, uncons, union, unionBy, unzip, updateAt, zip, zipWith, zipWithA, (!!), (..), (:), (\\))
 import Data.List.Lazy.NonEmpty as NEL
 import Data.Maybe (Maybe(..), isNothing, fromJust)
 import Data.Monoid.Additive (Additive(..))
 import Data.NonEmpty ((:|))
 import Data.Traversable (traverse)
 import Data.TraversableWithIndex (traverseWithIndex)
 import Data.Tuple (Tuple(..))
+import Data.Unfoldable (unfoldr)
+import Data.Unfoldable1 (unfoldr1)
+import Effect (Effect)
+import Effect.Console (log)
 import Partial.Unsafe (unsafePartial)
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testListLazy :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit
+testListLazy :: Effect Unit
 testListLazy = do
   let
     l = fromFoldable
@@ -270,6 +272,12 @@ testListLazy = do
   assert $ (take 2 (l [1, 2, 3])) == l [1, 2]
   assert $ (take 1 nil') == nil'
 
+  log "take should evaluate exactly n items which we needed"
+  assert let oops x = 0 : oops x
+             xs = 1 : defer oops
+          in take 1 xs == l [1]
+  -- If `take` evaluate more than once, it would crash with a stack overflow
+
   log "takeWhile should keep all values that match a predicate from the front of an list"
   assert $ (takeWhile (_ /= 2) (l [1, 2, 3])) == l [1]
   assert $ (takeWhile (_ /= 3) (l [1, 2, 3])) == l [1, 2]
@@ -396,9 +404,26 @@ testListLazy = do
                      ((10:20:30:nil) : (11:31:nil) : (32:nil) : nil)
   log "transpose nil == nil"
   assert $ transpose nil == (nil :: List (List Int))
+
   log "transpose (singleton nil) == nil"
   assert $ transpose (singleton nil) == (nil :: List (List Int))
 
+  log "unfoldr should maintain order"
+  assert $ (1..5) == unfoldr step 1
+
+  log "unfoldr1 should maintain order"
+  assert $ (1..5) == unfoldr1 step1 1
+
+  log "map should maintain order"
+  assert $ (1..5) == map identity (1..5)
+
+step :: Int -> Maybe (Tuple Int Int)
+step 6 = Nothing
+step n = Just (Tuple n (n + 1))
+
+step1 :: Int -> Tuple Int (Maybe Int)
+step1 n = Tuple n (if n >= 5 then Nothing else Just (n + 1))
+
 nil' :: List Int
 nil' = nil