takeWhile package:rio

takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString
rio RIO.ByteString RIO.ByteString.Lazy
takeWhile, applied to a predicate p and a ByteString xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.
takeWhile :: (a -> Bool) -> [a] -> [a]
rio RIO.List RIO.Prelude
takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p: 
takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []
takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
rio RIO.NonEmpty
takeWhile p xs returns the longest prefix of the stream xs for which the predicate p holds.
takeWhile :: (Char -> Bool) -> Text -> Text
rio RIO.Text RIO.Text.Lazy
O(n) takeWhile, applied to a predicate p and a Text, returns the longest prefix (possibly empty) of elements that satisfy p. Subject to fusion.
takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
rio RIO.Vector
O(n) Yield the longest prefix of elements satisfying the predicate. Current implementation is not copy-free, unless the result vector is fused away.
takeWhile :: (a -> Bool) -> Vector a -> Vector a
rio RIO.Vector.Boxed
O(n) Yield the longest prefix of elements satisfying the predicate. Current implementation is not copy-free, unless the result vector is fused away.
takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
rio RIO.Vector.Storable
O(n) Yield the longest prefix of elements satisfying the predicate. Current implementation is not copy-free, unless the result vector is fused away.
takeWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
rio RIO.Vector.Unboxed
O(n) Yield the longest prefix of elements satisfying the predicate. Current implementation is not copy-free, unless the result vector is fused away.
takeWhileAntitone :: (k -> Bool) -> Map k a -> Map k a
rio RIO.Map
O(log n). Take while a predicate on the keys holds. The user is responsible for ensuring that for all keys j and k in the map, j < k ==> p j >= p k. See note at spanAntitone. 
takeWhileAntitone p = fromDistinctAscList . takeWhile (p . fst) . toList
takeWhileAntitone p = filterWithKey (k _ -> p k)
takeWhileL :: (a -> Bool) -> Seq a -> Seq a
rio RIO.Seq
where <math> is the prefix length. takeWhileL, applied to a predicate p and a sequence xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.
takeWhileR :: (a -> Bool) -> Seq a -> Seq a
rio RIO.Seq
where <math> is the suffix length. takeWhileR, applied to a predicate p and a sequence xs, returns the longest suffix (possibly empty) of xs of elements that satisfy p. takeWhileR p xs is equivalent to reverse (takeWhileL p (reverse xs)).
takeWhileAntitone :: (a -> Bool) -> Set a -> Set a
rio RIO.Set
O(log n). Take while a predicate on the elements holds. The user is responsible for ensuring that for all elements j and k in the set, j < k ==> p j >= p k. See note at spanAntitone. 
takeWhileAntitone p = fromDistinctAscList . takeWhile p . toList
takeWhileAntitone p = filter p
takeWhileEnd :: (Char -> Bool) -> Text -> Text
rio RIO.Text
O(n) takeWhileEnd, applied to a predicate p and a Text, returns the longest suffix (possibly empty) of elements that satisfy p. Subject to fusion. Examples: 
>>> takeWhileEnd (=='o') "foo"
"oo"
takeWhileEnd :: (Char -> Bool) -> Text -> Text
rio RIO.Text.Lazy
O(n) takeWhileEnd, applied to a predicate p and a Text, returns the longest suffix (possibly empty) of elements that satisfy p. Examples: 
takeWhileEnd (=='o') "foo" == "oo"