769ce84 · streamly · git.iko.soy

426 let stop = return Nothing

427 single a = return (Just (a, nil))

428 yieldk a r = return (Just (a, fromStream r))

429− in unStreamShared (toStream m) defState stop single yieldk

429+ in unStream (toStream m) defState stop single yieldk

430

431-------------------------------------------------------------------------------

432-- Generation

543 let stop = return acc

544 single a = return (step a acc)

545 yieldk a r = go r >>= \b -> return (step a b)

546− in unStreamShared m1 defState stop single yieldk

546+ in unStream m1 defState stop single yieldk

547

548-- | Lazy right fold with a monadic step function.

549{-# INLINE foldrM #-}

554 let stop = return acc

555 single a = step a acc

556 yieldk a r = go r >>= step a

557− in unStreamShared m1 defState stop single yieldk

557+ in unStream m1 defState stop single yieldk

558

559{-# INLINE foldr1 #-}

560foldr1 :: (IsStream t, Monad m) => (a -> a -> a) -> t m a -> m (Maybe a)

568 let stp = return p

569 single a = return $ step a p

570 yieldk a r = fmap (step p) (go a r)

571− in unStreamShared m1 defState stp single yieldk

571+ in unStream m1 defState stp single yieldk

572

573-- | Strict left fold with an extraction function. Like the standard strict

574-- left fold, but applies a user supplied extraction function (the third

597 single a = sng $ step acc a

598 yieldk a r =

599 let stream = go r (step acc a)

600− in unStreamShared stream defState undefined sng yld

600+ in unStream stream defState undefined sng yld

601− in unStreamShared m1 defState stop single yieldk

601+ in unStream m1 defState stop single yieldk

602

603-- | Strict left associative fold.

604{-# INLINE foldl' #-}

615 let stop = acc >>= done

616 single a = acc >>= \b -> step b a >>= done

617 yieldk a r = acc >>= \b -> step b a >>= \x -> go (return x) r

618− in unStreamShared m1 defState stop single yieldk

618+ in unStream m1 defState stop single yieldk

619

620-- | Like 'foldl'' but with a monadic step function.

621foldlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> b -> t m a -> m b

633 let stop = return ()

634 single _ = return ()

635 yieldk _ r = go (toStream r)

636− in unStreamShared m1 defState stop single yieldk

636+ in unStream m1 defState stop single yieldk

637

638{-# INLINE null #-}

639null :: (IsStream t, Monad m) => t m a -> m Bool

641 let stop = return True

642 single _ = return False

643 yieldk _ _ = return False

644− in unStreamShared (toStream m) defState stop single yieldk

644+ in unStream (toStream m) defState stop single yieldk

645

646{-# INLINE head #-}

647head :: (IsStream t, Monad m) => t m a -> m (Maybe a)

649 let stop = return Nothing

650 single a = return (Just a)

651 yieldk a _ = return (Just a)

652− in unStreamShared (toStream m) defState stop single yieldk

652+ in unStream (toStream m) defState stop single yieldk

653

654{-# INLINE tail #-}

655tail :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))

657 let stop = return Nothing

658 single _ = return $ Just nil

659 yieldk _ r = return $ Just $ fromStream r

660− in unStreamShared (toStream m) defState stop single yieldk

660+ in unStream (toStream m) defState stop single yieldk

661

662{-# INLINE init #-}

663init :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))

671 go p m1 = Stream $ \_ stp sng yld ->

672 let single _ = sng p

673 yieldk a x = yld p $ go a x

674− in unStreamShared m1 defState stp single yieldk

674+ in unStream m1 defState stp single yieldk

675

676{-# INLINE elem #-}

677elem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool

681 let stop = return False

682 single a = return (a == e)

683 yieldk a r = if a == e then return True else go r

684− in unStreamShared m1 defState stop single yieldk

684+ in unStream m1 defState stop single yieldk

685

686{-# INLINE notElem #-}

687notElem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool

691 let stop = return True

692 single a = return (a /= e)

693 yieldk a r = if a == e then return False else go r

694− in unStreamShared m1 defState stop single yieldk

694+ in unStream m1 defState stop single yieldk

695

696all :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool

697all p m = go (toStream m)

701 | otherwise = return False

702 yieldk a r | p a = go r

703 | otherwise = return False

704− in unStreamShared m1 defState (return True) single yieldk

704+ in unStream m1 defState (return True) single yieldk

705

706any :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool

707any p m = go (toStream m)

711 | otherwise = return False

712 yieldk a r | p a = return True

713 | otherwise = go r

714− in unStreamShared m1 defState (return False) single yieldk

714+ in unStream m1 defState (return False) single yieldk

715

716-- | Extract the last element of the stream, if any.

717{-# INLINE last #-}

726 let stop = return Nothing

727 single a = return (Just a)

728 yieldk a r = go (Just a) r

729− in unStreamShared m1 defState stop single yieldk

729+ in unStream m1 defState stop single yieldk

730

731 go (Just res) m1 =

732 let stop = return (Just res)

738 if res <= a

739 then go (Just res) r

740 else go (Just a) r

741− in unStreamShared m1 defState stop single yieldk

741+ in unStream m1 defState stop single yieldk

742

743{-# INLINE minimumBy #-}

744minimumBy

750 let stop = return Nothing

751 single a = return (Just a)

752 yieldk a r = go (Just a) r

753− in unStreamShared m1 defState stop single yieldk

753+ in unStream m1 defState stop single yieldk

754

755 go (Just res) m1 =

756 let stop = return (Just res)

760 yieldk a r = case cmp res a of

761 GT -> go (Just a) r

762 _ -> go (Just res) r

763− in unStreamShared m1 defState stop single yieldk

763+ in unStream m1 defState stop single yieldk

764

765{-# INLINE maximum #-}

766maximum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)

770 let stop = return Nothing

771 single a = return (Just a)

772 yieldk a r = go (Just a) r

773− in unStreamShared m1 defState stop single yieldk

773+ in unStream m1 defState stop single yieldk

774

775 go (Just res) m1 =

776 let stop = return (Just res)

782 if res <= a

783 then go (Just a) r

784 else go (Just res) r

785− in unStreamShared m1 defState stop single yieldk

785+ in unStream m1 defState stop single yieldk

786

787{-# INLINE maximumBy #-}

788maximumBy :: (IsStream t, Monad m) => (a -> a -> Ordering) -> t m a -> m (Maybe a)

792 let stop = return Nothing

793 single a = return (Just a)

794 yieldk a r = go (Just a) r

795− in unStreamShared m1 defState stop single yieldk

795+ in unStream m1 defState stop single yieldk

796

797 go (Just res) m1 =

798 let stop = return (Just res)

802 yieldk a r = case cmp res a of

803 GT -> go (Just res) r

804 _ -> go (Just a) r

805− in unStreamShared m1 defState stop single yieldk

805+ in unStream m1 defState stop single yieldk

806

807{-# INLINE (!!) #-}

808(!!) :: (IsStream t, Monad m) => t m a -> Int -> m (Maybe a)

814 yieldk a x | n < 0 = return Nothing

815 | n == 0 = return $ Just a

816 | otherwise = go (n - 1) x

817− in unStreamShared m1 defState (return Nothing) single yieldk

817+ in unStream m1 defState (return Nothing) single yieldk

818

819{-# INLINE lookup #-}

820lookup :: (IsStream t, Monad m, Eq a) => a -> t m (a, b) -> m (Maybe b)

825 | otherwise = return Nothing

826 yieldk (a, b) x | a == e = return $ Just b

827 | otherwise = go x

828− in unStreamShared m1 defState (return Nothing) single yieldk

828+ in unStream m1 defState (return Nothing) single yieldk

829

830{-# INLINE findM #-}

831findM :: (IsStream t, Monad m) => (a -> m Bool) -> t m a -> m (Maybe a)

838 yieldk a x = do

839 b <- p a

840 if b then return $ Just a else go x

841− in unStreamShared m1 defState (return Nothing) single yieldk

841+ in unStream m1 defState (return Nothing) single yieldk

842

843{-# INLINE find #-}

844find :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m (Maybe a)

868 let stop = return ()

869 single a = void (f a)

870 yieldk a r = f a >> go r

871− in unStreamShared m1 defState stop single yieldk

871+ in unStream m1 defState stop single yieldk

872

873------------------------------------------------------------------------------

874-- Converting folds

1154 | otherwise = return Nothing

1155 yieldk a r | h == a = go h r

1156 | otherwise = return Nothing

1157− in unStreamShared m1 defState (return $ Just h) single yieldk

1157+ in unStream m1 defState (return $ Just h) single yieldk

1158

1159------------------------------------------------------------------------------

1160-- Semigroup