Documentation

Like when, but where the test can be monadic.

Like unless, but where the test can be monadic.

Like if, but where the test can be monadic.

Uses safe-exceptions.

Safe decodeUtf8With. Replaces an invalid input byte with the Unicode replacement character U+FFFD.

Escape a version for use in regex

Gathering monoidal values

>>> traverseFold (pure . (:["0"])) ["1","2"]
["1","0","2","0"]
>>> traverseFold Just ["1","2","3","4","5"]
Just "12345"

\t -> traverseFold Just t === Just (mconcat t)

Gathering monoidal values

Strip \r and \n from Strings

>>> stripNewline "foo\n\n\n"
"foo"
>>> stripNewline "foo\n\n\nfoo"
"foofoo"
>>> stripNewline "foo\r"
"foo"
>>> stripNewline "foo"
"foo"

\t -> stripNewline (t <> "\n") === stripNewline t

\t -> not (any (isNewLine . c2w) t) ==> stripNewline t == t

Strip \r and \n from end of String.

>>> stripNewlineEnd "foo\n\n\n"
"foo"
>>> stripNewlineEnd "foo\n\n\nfoo"
"foo\n\n\nfoo"
>>> stripNewlineEnd "foo\r"
"foo"
>>> stripNewlineEnd "foo"
"foo"

\t -> stripNewlineEnd (t <> "\n") === stripNewlineEnd t

\t -> not (any (isNewLine . c2w) t) ==> stripNewlineEnd t == t

Strip \r and \n from Texts

>>> stripNewline' "foo\n\n\n"
"foo"
>>> stripNewline' "foo\n\n\nfoo"
"foofoo"
>>> stripNewline' "foo\r"
"foo"
>>> stripNewline' "foo"
"foo"

\t -> stripNewline' (t <> "\n") === stripNewline' t

\t -> not (T.any (isNewLine . c2w) t) ==> stripNewline' t == t

Is the word8 a newline?

>>> isNewLine (c2w '\n')
True
>>> isNewLine (c2w '\r')
True

\w -> w /= _lf && w /= _cr ==> not (isNewLine w)

Split on a PVP suffix.

>>> splitOnPVP "-" "ghc-iserv-dyn-9.3.20210706"
("ghc-iserv-dyn","9.3.20210706")
>>> splitOnPVP "-" "ghc-iserv-dyn"
("ghc-iserv-dyn","")

Like find, but where the test can be monadic.

>>> findM (Just . C.isUpper) "teST"
Just (Just 'S')
>>> findM (Just . C.isUpper) "test"
Just Nothing
>>> findM (Just . const True) ["x",undefined]
Just (Just "x")

Drops the given suffix from a list. It returns the original sequence if the sequence doesn't end with the given suffix.

>>> dropSuffix "!" "Hello World!"
"Hello World"
>>> dropSuffix "!" "Hello World!!"
"Hello World!"
>>> dropSuffix "!" "Hello World."
"Hello World."

Return the prefix of the second list if its suffix matches the entire first list.

>>> stripSuffix "bar" "foobar"
Just "foo"
>>> stripSuffix ""    "baz"
Just "baz"
>>> stripSuffix "foo" "quux"
Nothing

Drops the given prefix from a list. It returns the original sequence if the sequence doesn't start with the given prefix.

>>> dropPrefix "Mr. " "Mr. Men"
"Men"
>>> dropPrefix "Mr. " "Dr. Men"
"Dr. Men"

Break a list into pieces separated by the first list argument, consuming the delimiter. An empty delimiter is invalid, and will cause an error to be raised.

>>> splitOn "\r\n" "a\r\nb\r\nd\r\ne"
["a","b","d","e"]
>>> splitOn "aaa"  "aaaXaaaXaaaXaaa"
["","X","X","X",""]
>>> splitOn "x"    "x"
["",""]
>>> splitOn "x"    ""
[""]

\s x -> s /= "" ==> intercalate s (splitOn s x) == x

\c x -> splitOn [c] x                           == split (==c) x

Splits a list into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output.

>>> split (== 'a') "aabbaca"
["","","bb","c",""]
>>> split (== 'a') ""
[""]
>>> split (== ':') "::xyz:abc::123::"
["","","xyz","abc","","123","",""]
>>> split (== ',') "my,list,here"
["my","list","here"]

Find the first instance of needle in haystack. The first element of the returned tuple is the prefix of haystack before needle is matched. The second is the remainder of haystack, starting with the match. If you want the remainder without the match, use stripInfix.

>>> breakOn "::" "a::b::c"
("a","::b::c")
>>> breakOn "/" "foobar"
("foobar","")

\needle haystack -> let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack