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

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.

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, 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.

Split a string containing a list of authors in BibTeX notation.

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''", ...]