Documentation

It is an Iteratee that can produce partial results.

It r a consumes a feed of rs and produces as on the way. New values can be fed using simplifyIt, the current (partial or final) result is extracted using extract.

>>> let keepIt    a = Pure a
>>> let replaceIt a = It a replaceIt

>>> extract (keepIt 0)
0

>>> extract (replaceIt 0)
0

>>> extract (simplifyIt (keepIt 0) 5)
0

>>> extract (simplifyIt (replaceIt 0) 5)
5

Consumes input until a value can be produced.

>>> :{
let needTen = needIt 0 (\n -> if n < 10 then Nothing else Just n) :: It Int Int
:}

>>> extract needTen
0

>>> extract (simplifyIt needTen 5)
0

>>> extract (simplifyIt needTen 11)
11

>>> extract (simplifyIt (simplifyIt (simplifyIt needTen 5) 11) 15)
11

Consumes input and produces partial results until a condition is met. Unlike needIt, partial results are already returned when the condition is not fulfilled yet.

>>> :{
let wantTen :: It Int Int
    wantTen = wantIt 0 (\n -> (# n >= 10, n #))
:}

>>> extract wantTen
0

>>> extract (simplifyIt wantTen 5)
5

>>> extract (simplifyIt wantTen 11)
11

>>> extract (simplifyIt (simplifyIt (simplifyIt wantTen 5) 11) 15)
11

Feed a value to It, obtaining a new (partial or final) result.

The generalized fold (Böhm-Berarducci decoding) over 'It r a'.

foldIt satisfies the property:

foldIt Pure It = id

Scott decoding of 'It r a'.

The scott decoding is similar to the generalized fold over a data type, but leaves the recursion step to the calling function.

runIt satiesfies the property:

runIt Pure It = id

See also the Scott decoding of lists:

runList :: (a -> [a] -> b) -> b -> [a] -> b

and compare it with foldr (the Böhm-Berarducci decoding for lists):

foldr :: (a -> b -> b) -> b -> [a] -> b

Given a position, go there, and grab the rest of the line forward from that point.

>>> :set -XOverloadedStrings
>>> let secondLine = fillIt Nothing (const Just) (delta ("foo\nb" :: Strict.ByteString))

>>> extract secondLine
Nothing

>>> extract (simplifyIt secondLine (ropeBS "foo"))
Nothing

>>> extract (simplifyIt secondLine (ropeBS "foo\nbar"))
Just "ar"

>>> extract (simplifyIt secondLine (ropeBS "foo\nbar\nbaz"))
Just "ar\n"

Return the text of the line that contains a given position

>>> :set -XOverloadedStrings
>>> let secondLine = rewindIt (delta ("foo\nb" :: Strict.ByteString))

>>> extract secondLine
Nothing

>>> extract (simplifyIt secondLine (ropeBS "foo"))
Nothing

>>> extract (simplifyIt secondLine (ropeBS "foo\nbar"))
Just "bar"

>>> extract (simplifyIt secondLine (ropeBS "foo\nbar\nbaz"))
Just "bar\n"

Return the text between two offsets.

>>> :set -XOverloadedStrings
>>> let secondLine = sliceIt (delta ("foo\n" :: Strict.ByteString)) (delta ("foo\nbar\n" :: Strict.ByteString))

>>> extract secondLine
""

>>> extract (simplifyIt secondLine (ropeBS "foo"))
""

>>> extract (simplifyIt secondLine (ropeBS "foo\nbar"))
"bar"

>>> extract (simplifyIt secondLine (ropeBS "foo\nbar\nbaz"))
"bar\n"