Add Unfoldable1 instances for Unfoldables

Author: garyb

src/Data/List/Lazy/Types.purs

@@ -24,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))
@@ -140,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

src/Data/List/Types.purs

@@ -25,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)
 
@@ -98,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

test/Test/Data/List.purs

@@ -2,8 +2,6 @@ module Test.Data.List (testList) where
 
 import Prelude
 
-import Effect (Effect)
-import Effect.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,6 +13,9 @@ 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)
 
@@ -357,6 +358,9 @@ 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 identity (1..5)
 
@@ -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,19 +3,21 @@ module Test.Data.List.Lazy (testListLazy) where
 import Prelude
 
 import Control.Lazy (defer)
-import Effect (Effect)
-import Effect.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)
 
@@ -396,9 +398,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