Data.List.Match

Documentation

take :: [b] -> [a] -> [a]

Make a list as long as another one

\(Shape xs) (List ys) -> Match.take xs ys == List.take (length xs) ys

drop :: [b] -> [a] -> [a]

Drop as many elements as the first list is long

\(Shape xs) (List ys) -> Match.drop xs ys == List.drop (length xs) ys

\(Shape xs) (List ys) -> Match.take xs ys ++ Match.drop xs ys == ys

splitAt :: [b] -> [a] -> ([a], [a])

\(Shape xs) (List ys) -> Match.splitAt xs ys == (Match.take xs ys, Match.drop xs ys)

\(Shape xs) (List ys) -> Match.splitAt xs ys == List.splitAt (length xs) ys

takeRev :: [b] -> [a] -> [a]

\(Shape xs) (List ys) -> Match.takeRev xs ys == reverse (Match.take xs (reverse ys))

dropRev :: [b] -> [a] -> [a]

\(Shape xs) (List ys) -> Match.dropRev xs ys == reverse (Match.drop xs (reverse ys))

replicate :: [a] -> b -> [b]

Specialisation of $>.

equalLength :: [a] -> [b] -> Bool

Check whether two lists with different element types have equal length. It holds

\(Shape xs) (List ys) -> equalLength xs ys == (length xs == length ys)

but equalLength is more efficient.

compareLength :: [a] -> [b] -> Ordering

Compare the length of two lists over different types. It holds

\(Shape xs) (List ys) -> compareLength xs ys == compare (length xs) (length ys)

but compareLength is more efficient.

lessOrEqualLength :: [a] -> [b] -> Bool

lessOrEqualLength x y is almost the same as compareLength x y <= EQ, but

>>> lessOrEqualLength "" undefined
True

whereas compareLength [] undefined <= EQ = undefined.

shorterList :: [a] -> [a] -> [a]

Returns the shorter one of two lists. It works also for infinite lists as much as possible. E.g.

>>> shorterList (shorterList (repeat 'a') (repeat 'b')) "abc"
"abc"

The trick is, that the skeleton of the resulting list is constructed using zipWith without touching the elements. The contents is then computed (only) if requested.