:: String -> [String] -package:MissingH

Splits the argument into a list of lines stripped of their terminating \n characters. The \n terminator is optional in a final non-empty line of the argument string. For example:

>>> lines ""           -- empty input contains no lines
[]

>>> lines "\n"         -- single empty line
[""]

>>> lines "one"        -- single unterminated line
["one"]

>>> lines "one\n"      -- single non-empty line
["one"]

>>> lines "one\n\n"    -- second line is empty
["one",""]

>>> lines "one\ntwo"   -- second line is unterminated
["one","two"]

>>> lines "one\ntwo\n" -- two non-empty lines
["one","two"]

When the argument string is empty, or ends in a \n character, it can be recovered by passing the result of lines to the unlines function. Otherwise, unlines appends the missing terminating \n. This makes unlines . lines idempotent:

(unlines . lines) . (unlines . lines) = (unlines . lines)

words breaks a string up into a list of words, which were delimited by white space (as defined by isSpace). This function trims any white spaces at the beginning and at the end.

>>> words "Lorem ipsum\ndolor"
["Lorem","ipsum","dolor"]

>>> words " foo bar "
["foo","bar"]

Given a string of concatenated strings, separate each by removing a layer of quoting and/or escaping of certain characters. These characters are: any whitespace, single quote, double quote, and the backslash character. The backslash character always escapes (i.e., passes through without further consideration) the character which follows. Characters can also be escaped in blocks by quoting (i.e., surrounding the blocks with matching pairs of either single- or double-quotes which are not themselves escaped). Any whitespace which appears outside of either of the quoting and escaping mechanisms, is interpreted as having been added by this special concatenation process to designate where the boundaries are between the original, un-concatenated list of strings. These added whitespace characters are removed from the output.

unescapeArgs "hello\\ \\\"world\\\"\n" == ["hello \"world\""]

Like showLitString (expand escape characters using Haskell escape conventions), but * break the string into multiple lines * wrap the entire thing in double quotes Example: showMultiLineString "hellongoodbyenblah" returns [""hello\n\", "\goodbyen\", "\blah""]

Helper function to split a string into a list of arguments. It's supposed to handle quoted things sensibly, eg:

splitArgs "--foo=\"C:/Program Files/Bar/" --baz"
= ["--foo=C:/Program Files/Bar", "--baz"]

splitArgs "\"-DMSGSTR=\\\"foo bar\\\"\" --baz"
= ["-DMSGSTR=\"foo bar\"","--baz"]

words breaks a string up into a list of words, which were delimited by white space.

>>> words "Lorem ipsum\ndolor"
["Lorem","ipsum","dolor"]

lines breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines. Note that after splitting the string at newline characters, the last part of the string is considered a line even if it doesn't end with a newline. For example,

>>> lines ""
[]

>>> lines "\n"
[""]

>>> lines "one"
["one"]

>>> lines "one\n"
["one"]

>>> lines "one\n\n"
["one",""]

>>> lines "one\ntwo"
["one","two"]

>>> lines "one\ntwo\n"
["one","two"]

Thus lines s contains at least as many elements as newlines in s.

Given a string, split into the available arguments. The inverse of joinArgs.

linesCR breaks a String up into a list of Strings at newline Chars. It is very similar to lines, but it also removes any trailing 'r' Chars. The resulting String values do not contain newlines or trailing 'r' characters.

Get the path components from a String.

Return the aliases for a given converter or alias name.

Returns a list of languages appropriate for the given file extension.

Split lines in a string using newline as separation. Note that carriage return preceding a newline are also strip for maximum compatibility between Windows and Unix system.

Split words in a string using spaces as separation

words "Hello Foundation"

• Hello, Foundation

Quote-aware version of words - don't split on spaces which are inside quotes. NB correctly handles "a'b" but not "'a'". Can raise an error if parsing fails.

Break a comma-separated string. Result strings are trimmed.

Breaks up a string into substrings. Returns every maximal subsequence of zero or more characters distinct from ..

splitOnDots ""         == [""]
splitOnDots "foo.bar"  == ["foo", "bar"]
splitOnDots ".foo.bar" == ["", "foo", "bar"]
splitOnDots "foo.bar." == ["foo", "bar", ""]
splitOnDots "foo..bar" == ["foo", "", "bar"]

Parse and return all variables that are not in scope from a ghc error message.

Split a string at the commas and remove leading spaces.