@@ -136,6 +136,16 @@ sourceUnfoldrMAction value n = S.serially $ S.unfoldrM step n
136136 then return Nothing
137137 else return (Just (return cnt, cnt + 1))
138138
139+{-# INLINE sourceUnfoldrAction #-}
140+sourceUnfoldrAction :: (S.IsStream t, Monad m, Monad m1)
141+ => Int -> Int -> t m (m1 Int)
142+sourceUnfoldrAction value n = S.serially $ S.unfoldr step n
143+ where
144+ step cnt =
145+ if cnt > n + value
146+ then Nothing
147+ else (Just (return cnt, cnt + 1))
148+
139149-- fromIndices
140150
141151{-# INLINE sourceFromIndices #-}
@@ -275,6 +285,15 @@ toList = S.toList
275285toListRev :: Monad m => Stream m Int -> m [Int]
276286toListRev = Internal.toListRev
277287
288+{-# INLINE foldrMElem #-}
289+foldrMElem :: Monad m => Int -> Stream m Int -> m Bool
290+foldrMElem e m = S.foldrM (\x xs -> if x == e then return P.True else xs)
291+ (return P.False) m
292+
293+{-# INLINE foldrMToStream #-}
294+foldrMToStream :: Monad m => Stream m Int -> m (Stream Identity Int)
295+foldrMToStream = S.foldr S.cons S.nil
296+
278297foldrMBuild = S.foldrM (\x xs -> xs >>= return . (x :)) (return [])
279298foldl'Build = S.foldl' (flip (:)) []
280299foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) []
@@ -1047,14 +1066,137 @@ readInstanceList str =
10471066pureFoldl' :: Stream Identity Int -> Int
10481067pureFoldl' = runIdentity . S.foldl' (+) 0
10491068
1069+-------------------------------------------------------------------------------
1070+-- Foldable Instance
1071+-------------------------------------------------------------------------------
1072+
10501073{-# INLINE foldableFoldl' #-}
1051−foldableFoldl' :: Stream Identity Int -> Int
1052−foldableFoldl' = F.foldl' (+) 0
1074+foldableFoldl' :: Int -> Int -> Int
1075+foldableFoldl' value n =
1076+ F.foldl' (+) 0 (sourceUnfoldr value n :: S.SerialT Identity Int)
1077+
1078+{-# INLINE foldableFoldrElem #-}
1079+foldableFoldrElem :: Int -> Int -> Bool
1080+foldableFoldrElem value n =
1081+ F.foldr (\x xs -> if x == value then P.True else xs)
1082+ (P.False)
1083+ (sourceUnfoldr value n :: S.SerialT Identity Int)
10531084
10541085{-# INLINE foldableSum #-}
1055−foldableSum :: Stream Identity Int -> Int
1056−foldableSum = P.sum
1086+foldableSum :: Int -> Int -> Int
1087+foldableSum value n =
1088+ P.sum (sourceUnfoldr value n :: S.SerialT Identity Int)
1089+
1090+{-# INLINE foldableProduct #-}
1091+foldableProduct :: Int -> Int -> Int
1092+foldableProduct value n =
1093+ P.product (sourceUnfoldr value n :: S.SerialT Identity Int)
1094+
1095+{-# INLINE foldableNull #-}
1096+foldableNull :: Int -> Int -> Bool
1097+foldableNull value n =
1098+ P.null (sourceUnfoldr value n :: S.SerialT Identity Int)
1099+
1100+{-# INLINE foldableElem #-}
1101+foldableElem :: Int -> Int -> Bool
1102+foldableElem value n =
1103+ P.elem value (sourceUnfoldr value n :: S.SerialT Identity Int)
1104+
1105+{-# INLINE foldableNotElem #-}
1106+foldableNotElem :: Int -> Int -> Bool
1107+foldableNotElem value n =
1108+ P.notElem value (sourceUnfoldr value n :: S.SerialT Identity Int)
1109+
1110+{-# INLINE foldableFind #-}
1111+foldableFind :: Int -> Int -> Maybe Int
1112+foldableFind value n =
1113+ F.find (== (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)
1114+
1115+{-# INLINE foldableAll #-}
1116+foldableAll :: Int -> Int -> Bool
1117+foldableAll value n =
1118+ P.all (<= (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)
1119+
1120+{-# INLINE foldableAny #-}
1121+foldableAny :: Int -> Int -> Bool
1122+foldableAny value n =
1123+ P.any (> (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)
1124+
1125+{-# INLINE foldableAnd #-}
1126+foldableAnd :: Int -> Int -> Bool
1127+foldableAnd value n =
1128+ P.and $ S.map (<= (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)
1129+
1130+{-# INLINE foldableOr #-}
1131+foldableOr :: Int -> Int -> Bool
1132+foldableOr value n =
1133+ P.or $ S.map (> (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)
1134+
1135+{-# INLINE foldableLength #-}
1136+foldableLength :: Int -> Int -> Int
1137+foldableLength value n =
1138+ P.length (sourceUnfoldr value n :: S.SerialT Identity Int)
1139+
1140+{-# INLINE foldableMin #-}
1141+foldableMin :: Int -> Int -> Int
1142+foldableMin value n =
1143+ P.minimum (sourceUnfoldr value n :: S.SerialT Identity Int)
1144+
1145+{-# INLINE foldableMax #-}
1146+foldableMax :: Int -> Int -> Int
1147+foldableMax value n =
1148+ P.maximum (sourceUnfoldr value n :: S.SerialT Identity Int)
1149+
1150+{-# INLINE foldableMinBy #-}
1151+foldableMinBy :: Int -> Int -> Int
1152+foldableMinBy value n =
1153+ F.minimumBy compare (sourceUnfoldr value n :: S.SerialT Identity Int)
1154+
1155+{-# INLINE foldableListMinBy #-}
1156+foldableListMinBy :: Int -> Int -> Int
1157+foldableListMinBy value n = F.minimumBy compare [1..value+n]
1158+
1159+{-# INLINE foldableMaxBy #-}
1160+foldableMaxBy :: Int -> Int -> Int
1161+foldableMaxBy value n =
1162+ F.maximumBy compare (sourceUnfoldr value n :: S.SerialT Identity Int)
1163+
1164+{-# INLINE foldableToList #-}
1165+foldableToList :: Int -> Int -> [Int]
1166+foldableToList value n =
1167+ F.toList (sourceUnfoldr value n :: S.SerialT Identity Int)
1168+
1169+{-# INLINE foldableMapM_ #-}
1170+foldableMapM_ :: Monad m => Int -> Int -> m ()
1171+foldableMapM_ value n =
1172+ F.mapM_ (\_ -> return ()) (sourceUnfoldr value n :: S.SerialT Identity Int)
1173+
1174+{-# INLINE foldableSequence_ #-}
1175+foldableSequence_ :: Int -> Int -> IO ()
1176+foldableSequence_ value n =
1177+ F.sequence_ (sourceUnfoldrAction value n :: S.SerialT Identity (IO Int))
1178+
1179+{-# INLINE foldableMsum #-}
1180+foldableMsum :: Int -> Int -> IO Int
1181+foldableMsum value n =
1182+ F.msum (sourceUnfoldrAction value n :: S.SerialT Identity (IO Int))
1183+
1184+-------------------------------------------------------------------------------
1185+-- Traversable Instance
1186+-------------------------------------------------------------------------------
1187+
1188+{-# INLINE traversableTraverse #-}
1189+traversableTraverse :: Stream Identity Int -> IO (Stream Identity Int)
1190+traversableTraverse = P.traverse return
1191+
1192+{-# INLINE traversableSequenceA #-}
1193+traversableSequenceA :: Stream Identity Int -> IO (Stream Identity Int)
1194+traversableSequenceA = P.sequenceA . P.fmap return
10571195
10581196{-# INLINE traversableMapM #-}
10591197traversableMapM :: Stream Identity Int -> IO (Stream Identity Int)
10601198traversableMapM = P.mapM return
1199+
1200+{-# INLINE traversableSequence #-}
1201+traversableSequence :: Stream Identity Int -> IO (Stream Identity Int)
1202+traversableSequence = P.sequence . P.fmap return