:: String -> [String]

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"
>>> lines "one\n"
>>> lines "one\n\n"
>>> lines "one\ntwo"
>>> lines "one\ntwo\n"
Thus lines s contains at least as many elements as newlines in s.
words breaks a string up into a list of words, which were delimited by white space.
>>> words "Lorem ipsum\ndolor"
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" == escapeArgs "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"]
Given a string, split into the available arguments. The inverse of joinArgs.
Get the path components from a String.
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.
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"
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"]
Returns an infinite list of variable names based on the given template.
> variableNamesFromTemplate "x"
["x", "y", "z", "x'", "y'", ...]
> variableNamesFromTemplate "p"
["p", "q", "r", "p'", "q'", ...]
> variableNamesFromTemplate "xy"
["xy", "zw", "xy'", "zw'", "xy''", ...]
Part of the lexer prelude needed when string literals are to be lexed. Defines an interface to the Buffer.
Split a string at the commas and remove leading spaces.