span -package:utf8-string

span, applied to a predicate p and a list xs, returns a tuple where first element is the longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list: span p xs is equivalent to (takeWhile p xs, dropWhile p xs), even if p is _|_.

Laziness

>>> span undefined []
([],[])

>>> fst (span (const False) undefined)
*** Exception: Prelude.undefined

>>> fst (span (const False) (undefined : undefined))
[]

>>> take 1 (fst (span (const True) (1 : undefined)))
[1]

span produces the first component of the tuple lazily:

>>> take 10 (fst (span (const True) [1..]))
[1,2,3,4,5,6,7,8,9,10]

Examples

>>> span (< 3) [1,2,3,4,1,2,3,4]
([1,2],[3,4,1,2,3,4])

>>> span (< 9) [1,2,3]
([1,2,3],[])

>>> span (< 0) [1,2,3]
([],[1,2,3])

span p xs returns the longest prefix of xs that satisfies p, together with the remainder of the stream.

'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)
xs == ys ++ zs where (ys, zs) = 'span' p xs

Similar to span, returns the longest (possibly empty) prefix of elements satisfying the predicate and the remainder of the string. span p is equivalent to break (not . p) and to (takeWhile p &&& dropWhile p).

span p xs breaks the ByteString into two segments. It is equivalent to (takeWhile p xs, dropWhile p xs)

Similar to span, returns the longest (possibly empty) prefix of elements satisfying the predicate and the remainder of the string. span p is equivalent to break (not . p) and to (takeWhile p &&& dropWhile p).

O(n) span, applied to a predicate p and text t, returns a pair whose first element is the longest prefix (possibly empty) of t of elements that satisfy p, and whose second is the remainder of the text.

>>> T.span (=='0') "000AB"
("000","AB")

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying. Does not fuse.

Examples

>>> import qualified Data.Vector as V

>>> V.span (<4) $ V.generate 10 id
([0,1,2,3],[4,5,6,7,8,9])

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying. Does not fuse.

Examples

>>> import qualified Data.Vector.Strict as V

>>> V.span (<4) $ V.generate 10 id
([0,1,2,3],[4,5,6,7,8,9])

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying. Does not fuse.

Examples

>>> import qualified Data.Vector.Primitive as VP

>>> VP.span (<4) $ VP.generate 10 id
([0,1,2,3],[4,5,6,7,8,9])

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying. Does not fuse.

Examples

>>> import qualified Data.Vector.Storable as VS

>>> VS.span (<4) $ VS.generate 10 id
([0,1,2,3],[4,5,6,7,8,9])

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying. Does not fuse.

Examples

>>> import qualified Data.Vector.Unboxed as VU

>>> VU.span (<4) $ VU.generate 10 id
([0,1,2,3],[4,5,6,7,8,9])

span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list:

>>> span (< 3) [1,2,3,4,1,2,3,4]
([1,2],[3,4,1,2,3,4])

>>> span (< 9) [1,2,3]
([1,2,3],[])

>>> span (< 0) [1,2,3]
([],[1,2,3])

span p xs is equivalent to (takeWhile p xs, dropWhile p xs)

Split a bytearray at the point where pred becomes invalid

Combinator for the <span> element. Example:

span $ span $ toHtml "foo"

Result:

<span><span>foo</span></span>

Combinator for the span attribute. Example:

div ! span "bar" $ "Hello."

Result:

<div span="bar">Hello.</div>

It is Data.List.span f undefined = undefined, whereas span f undefined = (undefined, undefined).

forAllPredicates $ \p xs -> Rev.span p xs == swap (mapPair (reverse, reverse) (List.span p (reverse xs)))

forAllPredicates $ \p xs -> Rev.span p xs == (Rev.dropWhile p xs, Rev.takeWhile p xs)

\x xs pad -> defined $ Match.take (pad::[()]) $ fst $ Rev.span ((x::Char)/=) $ cycle $ x:xs

forAllPredicates $ \p xs -> Rev.span p xs == swap (mapPair (reverse, reverse) (List.span p (reverse xs)))

forAllPredicates $ \p xs -> Rev.span p xs == (Rev.dropWhile p xs, Rev.takeWhile p xs)

\x xs pad -> defined $ mapFst length $ Rev.span ((x::Char)/=) $ Match.replicate (pad::[()]) undefined ++ x:xs

Stream elements until one fails the condition, return the rest.

span p xs breaks the ByteString into two segments. It is equivalent to (takeWhile p xs, dropWhile p xs)

span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list:

span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
span (< 9) [1,2,3] == ([1,2,3],[])
span (< 0) [1,2,3] == ([],[1,2,3])

span p xs is equivalent to (takeWhile p xs, dropWhile p xs)

O(n) span, applied to a predicate p and text t, returns a pair whose first element is the longest prefix (possibly empty) of t of elements that satisfy p, and whose second is the remainder of the list.

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying.

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying.