BNFC.Utils · BNFC-2.9.5 · horizon-platform

typetype ModuleName = String

#

The name of a module, e.g. Foo.Abs, Foo.Print etc.

valuewhen :: Monoid m => Bool -> m -> m

#

Generalization of when.

valueunless :: Monoid m => Bool -> m -> m

#

Generalization of unless.

valueunlessNull :: Monoid m => [a] -> ([a] -> m) -> m

#

Invoke continuation for non-empty list.

valueunlessNull' :: Monoid m => [a] -> (a -> [a] -> m) -> m

#

Invoke continuation for non-empty list.

valueapplyWhen :: Bool -> (a -> a) -> a -> a

#

when for the monoid of endofunctions 'a -> a'.

valueapplyUnless :: Bool -> (a -> a) -> a -> a

#

unless for the monoid of endofunctions 'a -> a'.

valuefor :: [a] -> (a -> b) -> [b]

#

Non-monadic forM.

valuewhenJust :: Monoid m => Maybe a -> (a -> m) -> m

#

Generalization of forM to Monoid.

valuecaseMaybe :: Maybe a -> b -> (a -> b) -> b

#

Rotation of maybe.

value(>.>) :: (a -> b) -> (b -> c) -> a -> c

#

Diagrammatic composition.

valuecurry3 :: ((a, b, c) -> d) -> a -> b -> c -> d

#

Converts an uncurried function to a curried function.

valueuncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d

#

Converts a curried function to a function on a triple.

valuesingleton :: a -> [a]

#

Give a telling name to the electric monkey.

valueheadWithDefault :: a -> [a] -> a

#

Get the first element of a list, fallback for empty list.

valuemapHead :: (a -> a) -> [a] -> [a]

#

Apply a function to the head of a list.

valuespanEnd :: (a -> Bool) -> [a] -> ([a], [a])

#

spanEnd p l == reverse (span p (reverse l)).

Invariant: l == front ++ end where (end, front) = spanEnd p l

(From package ghc, module Util.)

valueduplicatesOn :: (Foldable t, Ord b) => (a -> b) -> t a -> [List1 a]

#

Returns lists of elements whose normal form appears more than once.

Example2 expressions

>>> duplicatesOn id  [5,1,2,5,1][1 :| [1],5 :| [5]]>>> duplicatesOn abs [5,-5,1][5 :| [-5]]

valuegroupOn :: Eq b => (a -> b) -> [a] -> [List1 a]

#

Group consecutive elements that have the same normalform.

valueuniqOn :: Eq b => (a -> b) -> [a] -> [a]

#

Keep only the first of consecutive elements that have the same normalform.

valuehasNumericSuffix :: String -> Maybe (String, Integer)

#

Get a numeric suffix if it exists.

Example3 expressions

>>> hasNumericSuffix "hello world"Nothing>>> hasNumericSuffix "a1b2"Just ("a1b",2)>>> hasNumericSuffix "1234"Just ("",1234)

value(+++) :: String -> String -> String

#

Concatenate strings by a space.

value(++++) :: String -> String -> String

#

Concatenate strings by a newline.

value(+-+) :: String -> String -> String

#

Concatenate strings by an underscore.

value(+.+) :: String -> String -> String

#

Concatenate strings by a dot.

valueparensIf :: Bool -> String -> String

#

Wrap in parentheses if condition holds.

valuepad :: Int -> String -> String

#

Pad a string on the right by spaces to reach the desired length.

valuetable :: String -> [[String]] -> [String]

#

Make a list of rows with left-aligned columns from a matrix.

valuemkName :: [String] -> NameStyle -> String -> String

#

Generate a name in the given case style taking into account the reserved word of the language. Note that despite the fact that those name are mainly to be used in code rendering (type Doc), we return a String here to allow further manipulation of the name (like disambiguation) which is not possible in the Doc type.

Examples:

Example1 expression

>>> mkName [] LowerCase "FooBAR""foobar"

Example1 expression

>>> mkName [] UpperCase "FooBAR""FOOBAR"

Example1 expression

>>> mkName [] SnakeCase "FooBAR""foo_bar"

Example1 expression

>>> mkName [] CamelCase "FooBAR""FooBAR"

Example1 expression

>>> mkName [] CamelCase "Foo_bar""FooBar"

Example1 expression

>>> mkName [] MixedCase "FooBAR""fooBAR"

Example1 expression

>>> mkName ["foobar"] LowerCase "FooBAR""foobar_"

Example1 expression

>>> mkName ["foobar", "foobar_"] LowerCase "FooBAR""foobar__"

valuemkNames :: [String] -> NameStyle -> [String] -> [String]

#

Same as above but accept a list as argument and make sure that the names generated are uniques.

Example1 expression

>>> mkNames ["c"] LowerCase ["A", "b_", "a_", "c"]["a1","b","a2","c_"]

datadata NameStyle

#

Different case style

Constructors

LowerCase
e.g. lowercase
UpperCase
e.g. UPPERCASE
SnakeCase
e.g. snake_case
CamelCase
e.g. CamelCase
MixedCase
e.g. mixedCase
OrigCase
Keep original capitalization and form.

Instances2Eq, Show

Eq NameStyleDefined in BNFC-2.9.5 · BNFC.Utils
Show NameStyleDefined in BNFC-2.9.5 · BNFC.Utils

valuecapitalize :: String -> String

#

Make first letter uppercase.

valuelowerCase :: String -> Doc

#

Ident to lower case. >>> lowerCase MyIdent myident

valueupperCase :: String -> Doc

#

Ident to upper case. >>> upperCase MyIdent MYIDENT

valuemixedCase :: String -> Doc

#

To mixed case. >>> mixedCase "my_ident" myIdent

valuecamelCase :: String -> Doc

#

Ident to camel case. >>> camelCase "my_ident" MyIdent

valuecamelCase_ :: String -> String

#

valuesnakeCase :: String -> Doc

#

To snake case. >>> snakeCase MyIdent my_ident

valuesnakeCase_ :: String -> String

#

valuereplace

:: Eq a
=> a
Value to replace
-> a
Value to replace it with
-> [a]
-> [a]

#

Replace all occurences of a value by another value

valuewriteFileRep :: FilePath -> String -> IO ()

#

Write a file, after making a backup of an existing file with the same name. If an old version of the file exist and the new version is the same, keep the old file and don't create a .bak file. / New version by TH, 2010-09-23

valuecstring :: String -> Doc

#

A function that renders a c-like string with escaped characters. Note that although it's called cstring, this can be used with most (all) backend as they seem to mostly share escaping conventions. The c in the name is barely an homage for C being the oldest language in the lot.

Example1 expression

>>> cstring "foobar""foobar"

Example1 expression

>>> cstring "foobar\"""foobar\""

valuegetZonedTimeTruncatedToSeconds :: IO ZonedTime

#

valuesymbolToName :: String -> Maybe String

#

Print a symbol as typical token name, like "(" as LPAREN.