Rope of Text chunks with logarithmic concatenation. This rope offers two interfaces: one based on code points and another one based on UTF-16 code units. This comes with a price of double bookkeeping and is less performant than Data.Text.Rope or Data.Text.Utf16.Rope.

Create from Text, linear time.

Create from TextLines, linear time.

Glue chunks into Text, linear time.

Glue chunks into TextLines, linear time.

Check whether a rope is empty, O(1).

Split into lines by \n, similar to Data.Text.lines. Each line is produced in O(1).

>>> :set -XOverloadedStrings
>>> lines ""
[]
>>> lines "foo"
["foo"]
>>> lines "foo\n"
["foo"]
>>> lines "foo\n\n"
["foo",""]
>>> lines "foo\nbar"
["foo","bar"]

Equivalent to length . lines, but in logarithmic time.

>>> :set -XOverloadedStrings
>>> lengthInLines ""
0
>>> lengthInLines "foo"
1
>>> lengthInLines "foo\n"
1
>>> lengthInLines "foo\n\n"
2
>>> lengthInLines "foo\nbar"
2

If you do not care about ignoring the last newline character, you can use posLine . charLengthAsPosition instead, which works in O(1).

Split at given line, logarithmic time.

>>> :set -XOverloadedStrings
>>> map (\l -> splitAtLine l "foo\nbar") [0..3]
[("","foo\nbar"),("foo\n","bar"),("foo\nbar",""),("foo\nbar","")]

Length in code points, similar to Data.Text.length, O(1).

>>> :set -XOverloadedStrings
>>> charLength "fя𐀀"
3

Split at given code point, similar to Data.Text.splitAt. Takes linear time.

>>> :set -XOverloadedStrings
>>> map (\c -> charSplitAt c "fя𐀀") [0..4]
[("","fя𐀀"),("f","я𐀀"),("fя","𐀀"),("fя𐀀",""),("fя𐀀","")]

Measure text length as an amount of lines and columns, O(1).

>>> :set -XOverloadedStrings
>>> charLengthAsPosition "f𐀀"
Position {posLine = 0, posColumn = 2}
>>> charLengthAsPosition "f\n𐀀"
Position {posLine = 1, posColumn = 1}
>>> charLengthAsPosition "f\n𐀀\n"
Position {posLine = 2, posColumn = 0}

Combination of splitAtLine and subsequent charSplitAt. Time is linear in posColumn and logarithmic in posLine.

>>> :set -XOverloadedStrings
>>> charSplitAtPosition (Position 1 0) "f\n𐀀я"
("f\n","𐀀я")
>>> charSplitAtPosition (Position 1 1) "f\n𐀀я"
("f\n𐀀","я")
>>> charSplitAtPosition (Position 1 2) "f\n𐀀я"
("f\n𐀀я","")
>>> charSplitAtPosition (Position 0 2) "f\n𐀀я"
("f\n","𐀀я")
>>> charSplitAtPosition (Position 0 3) "f\n𐀀я"
("f\n𐀀","я")
>>> charSplitAtPosition (Position 0 4) "f\n𐀀я"
("f\n𐀀я","")

Length in UTF-16 code units, O(1).

>>> :set -XOverloadedStrings
>>> utf16Length "fя𐀀"
4

Split at given UTF-16 code unit. If requested number of code units splits a code point in half, return Nothing. Takes linear time.

>>> :set -XOverloadedStrings
>>> map (\c -> utf16SplitAt c "fя𐀀") [0..4]
[Just ("","fя𐀀"),Just ("f","я𐀀"),Just ("fя","𐀀"),Nothing,Just ("fя𐀀","")]

Measure text length as an amount of lines and columns, O(1).

>>> :set -XOverloadedStrings
>>> utf16LengthAsPosition "f𐀀"
Position {posLine = 0, posColumn = 3}
>>> utf16LengthAsPosition "f\n𐀀"
Position {posLine = 1, posColumn = 2}
>>> utf16LengthAsPosition "f\n𐀀\n"
Position {posLine = 2, posColumn = 0}

Combination of splitAtLine and subsequent utf16SplitAt. Time is linear in posColumn and logarithmic in posLine.

>>> :set -XOverloadedStrings
>>> utf16SplitAtPosition (Position 1 0) "f\n𐀀я"
Just ("f\n","𐀀я")
>>> utf16SplitAtPosition (Position 1 1) "f\n𐀀я"
Nothing
>>> utf16SplitAtPosition (Position 1 2) "f\n𐀀я"
Just ("f\n𐀀","я")
>>> utf16SplitAtPosition (Position 0 2) "f\n𐀀я"
Just ("f\n","𐀀я")
>>> utf16SplitAtPosition (Position 0 3) "f\n𐀀я"
Nothing
>>> utf16SplitAtPosition (Position 0 4) "f\n𐀀я"
Just ("f\n𐀀","я")