Add Unfoldable1 instances for non-empty lists

src/Data/List/Lazy/Types.purs

@@ -23,7 +23,7 @@ import Data.Ord (class Ord1, compare1)
 import Data.Traversable (class Traversable, traverse, sequence)
 import Data.TraversableWithIndex (class TraversableWithIndex, traverseWithIndex)
 import Data.Tuple (Tuple(..), snd)
-import Data.Unfoldable (class Unfoldable)
+import Data.Unfoldable (class Unfoldable, unfoldr1)
 import Data.Unfoldable1 (class Unfoldable1)
 
 -- | A lazy linked list.
@@ -270,6 +270,9 @@ instance traversableNonEmptyList :: Traversable NonEmptyList where
   sequence (NonEmptyList nel) =
     map (\xxs -> NonEmptyList $ defer \_ -> xxs) $ sequence (force nel)
 
+instance unfoldable1NonEmptyList :: Unfoldable1 NonEmptyList where
+  unfoldr1 f b = NonEmptyList $ defer \_ -> unfoldr1 f b
+
 instance functorWithIndexNonEmptyList :: FunctorWithIndex Int NonEmptyList where
   mapWithIndex f (NonEmptyList ne) = NonEmptyList $ defer \_ -> mapWithIndex (f <<< maybe 0 (add 1)) $ force ne
 

src/Data/List/Types.purs

@@ -213,6 +213,8 @@ derive newtype instance traversableNonEmptyList :: Traversable NonEmptyList
 
 derive newtype instance foldable1NonEmptyList :: Foldable1 NonEmptyList
 
+derive newtype instance unfoldable1NonEmptyList :: Unfoldable1 NonEmptyList
+
 instance functorWithIndexNonEmptyList :: FunctorWithIndex Int NonEmptyList where
   mapWithIndex fn (NonEmptyList ne) = NonEmptyList $ mapWithIndex (fn <<< maybe 0 (add 1)) ne
 

test/Test/Data/List/Lazy.purs

@@ -14,7 +14,7 @@ import Data.NonEmpty ((:|))
 import Data.Traversable (traverse)
 import Data.TraversableWithIndex (traverseWithIndex)
 import Data.Tuple (Tuple(..))
-import Data.Unfoldable (unfoldr)
+import Data.Unfoldable (replicate1, unfoldr)
 import Data.Unfoldable1 (unfoldr1)
 import Effect (Effect)
 import Effect.Console (log)
@@ -427,6 +427,12 @@ testListLazy = do
   log "map should maintain order"
   assert $ (1..5) == map identity (1..5)
 
+  log "unfoldable replicate1 should be stack-safe for NEL"
+  void $ pure $ NEL.length $ (replicate1 100000 1 :: NEL.NonEmptyList Int)
+
+  log "unfoldr1 should maintain order for NEL"
+  assert $ (nel (1 :| l [2, 3, 4, 5])) == unfoldr1 step1 1
+
 step :: Int -> Maybe (Tuple Int Int)
 step 6 = Nothing
 step n = Just (Tuple n (n + 1))

test/Test/Data/List/NonEmpty.purs

@@ -2,17 +2,18 @@ module Test.Data.List.NonEmpty (testNonEmptyList) where
 
 import Prelude
 
-import Effect (Effect)
-import Effect.Console (log)
 import Data.Foldable (class Foldable, foldM, foldMap, foldl, length)
 import Data.FoldableWithIndex (foldlWithIndex, foldrWithIndex, foldMapWithIndex)
-import Data.TraversableWithIndex (traverseWithIndex)
 import Data.List as L
 import Data.List.NonEmpty as NEL
 import Data.Maybe (Maybe(..))
 import Data.Monoid.Additive (Additive(..))
 import Data.NonEmpty ((:|))
+import Data.TraversableWithIndex (traverseWithIndex)
 import Data.Tuple (Tuple(..))
+import Data.Unfoldable (replicate, replicate1, unfoldr, unfoldr1)
+import Effect (Effect)
+import Effect.Console (log)
 import Test.Assert (assert)
 
 testNonEmptyList :: Effect Unit
@@ -265,6 +266,19 @@ testNonEmptyList = do
   assert $ map (traverseWithIndex (\i a -> Just $ i + a)) (NEL.fromFoldable [2, 2, 2])
            == Just (NEL.fromFoldable [2, 3, 4])
 
+  log "unfoldable replicate1 should be stack-safe"
+  void $ pure $ NEL.length $ (replicate1 100000 1 :: NEL.NonEmptyList Int)
+
+  log "unfoldr1 should maintain order"
+  assert $ (nel 1 [2, 3, 4, 5]) == unfoldr1 step1 1
+
+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))
+
 odd :: Int -> Boolean
 odd n = n `mod` 2 /= zero