Safe Haskell	Safe
Language	Haskell98

Text.Numeral.Render

Contents

Rendering numerals
Representation of numerals
Context of expressions

Synopsis

Rendering numerals

render Source #

Arguments

:: Repr	Representation.
-> Inflection	Initial inflection.
-> Exp	The expression to render.
-> Maybe Text

Renders an expression to a Text value according to a certain representation and inflection.

Representation of numerals

data Repr Source #

A representation for numerals.

A Repr contains all the information on how to render an Expression to a Text value.

Constructors

Repr

Fields

reprUnknown :: Maybe Text
Representation for unknown values.
reprValue :: Inflection -> Integer -> Maybe (Ctx Exp -> Text)
Renders a literal value. Not necessarily defined for every value.
reprNeg :: Maybe (Exp -> Ctx Exp -> Text)
Renders a negation. This concerns the negation itself, not the thing being negated.
reprAdd :: Maybe (Exp -> Exp -> Ctx Exp -> Text)
Renders an addition. This concerns the addition itself, not the things being added. For example: In "one hundred and eighty" this function would be responsible for rendering the "and".
reprMul :: Maybe (Exp -> Exp -> Ctx Exp -> Text)
Renders a multiplication. This concerns the multiplication itself, not the things being multiplied.
reprSub :: Maybe (Exp -> Exp -> Ctx Exp -> Text)
Renders a subtraction. This concerns the subtraction itself, not the things being subtracted.
reprFrac :: Maybe (Exp -> Exp -> Ctx Exp -> Text)
Renders a fraction. This concerns the fraction itself, not the numerator or the denominator.
reprScale :: ScaleRepr
Renders a step in a scale of large values.
reprNegCombine :: Maybe (Text -> Text -> Exp -> Text)
Combines a negation and the thing being negated. For example: this would combine "minus" and "three" into "minus three".
reprAddCombine :: Maybe (Text -> Text -> Exp -> Text -> Exp -> Text)
Combines an addition and the things being added.
reprMulCombine :: Maybe (Text -> Text -> Exp -> Text -> Exp -> Text)
Combines a multiplication and the things being multiplied.
reprSubCombine :: Maybe (Text -> Text -> Exp -> Text -> Exp -> Text)
Combines a subtraction and the things being subtracted.
reprFracCombine :: Maybe (Text -> Text -> Exp -> Text -> Exp -> Text)
Combines a fraction and the numerator and denominator.

type ScaleRepr Source #

Arguments

= Inflection
-> Integer	Base.
-> Integer	Offset.
-> Exp	Rank.
-> Ctx Exp	Rank context.
-> Maybe Text

Function that renders the representation of a step in a scale of large values. The value represented by the step is 10 ^ (rank * base + offset).

defaultRepr :: Repr Source #

The default representation.

Only the combining functions are defined. The rest are either Nothing or always produce Nothing.

Context of expressions

data Ctx a Source #

A context in which an Expression appears.

Constructors

CtxEmpty	The empty context. Used for top level expressions.
CtxNeg (Ctx a)	Negation context.
CtxAdd Side a (Ctx a)	Addition context.
CtxMul Side a (Ctx a)	Multiplication context.
CtxSub Side a (Ctx a)	Subtraction context.
CtxFrac Side a (Ctx a)	Fraction context.
CtxScale (Ctx a)	Scale context.

Instances

Eq a => Eq (Ctx a) Source #
Methods (==) :: Ctx a -> Ctx a -> Bool # (/=) :: Ctx a -> Ctx a -> Bool #
Show a => Show (Ctx a) Source #
Methods showsPrec :: Int -> Ctx a -> ShowS # show :: Ctx a -> String # showList :: [Ctx a] -> ShowS #

posIndex :: Ctx a -> Integer Source #

isOutside :: Side -> Ctx a -> Bool Source #

Checks whether a context is completely on the outside of an expression, either left or right.

Given the following expression:

Add (Lit 1000) (Add (Mul (Lit 2) (Lit 100)) (Add (Lit 4) (Mul (Lit 3) (Lit 10))))

On the left we have Lit 1000 and on the right Lit 10.