Money

Import this module qualified as follows:

import qualified Money

Note: This module exports many well-known currencies out-of-the-box, but you are not limited to the currencies mentioned here. You can simply create a new Scale instance, and voilà. If you want to add a new currency to the out-of-the-box offer, please request so in https://github.com/k0001/safe-money/issues and the authors will see to it.

This module offers plenty of documentation, but for a deep explanation of how all of the pieces fit together, please read https://ren.zone/articles/safe-money. Notice, however, that this library has changed a bit since that article was written. You can always see the change log to understand what has changed.

Dense monetary values

data Dense (currency :: Symbol)

Dense represents a dense monetary value for currency (usually a ISO-4217 currency code, but not necessarily) as a rational number.

While monetary values associated with a particular currency are discrete (e.g., an exact number of coins and bills), you can still treat monetary values as dense while operating on them. For example, the half of USD 3.41 is USD 1.705, which is not an amount that can't be represented as a number of USD cents (the smallest unit that can represent USD amounts). Nevertheless, if you do manage to represent USD 1.709 somehow, and you eventually multiply USD 1.705 by 4 for example, then you end up with USD 6.82, which is again a value representable as USD cents. In other words, Dense monetary values allow us to perform precise calculations deferring the conversion to a Discrete monetary values as much as posible. Once you are ready to approximate a Dense value to a Discrete value you can use one discreteFromDense. Otherwise, using toRational you can obtain a precise Rational representation.

Instances

Eq (Dense currency)

Methods

(==) :: Dense currency -> Dense currency -> Bool

(/=) :: Dense currency -> Dense currency -> Bool

ErrFractionalDense => Fractional (Dense currency)

Methods

(/) :: Dense currency -> Dense currency -> Dense currency

recip :: Dense currency -> Dense currency

fromRational :: Rational -> Dense currency

Num (Dense currency)

Notice that multiplication of Dense values doesn't make sense:

(*) :: Dense currency -> Dense currency -> Dense currency

How is * implemented, then? It behaves as the scalar multiplication of a Dense amount by a Rational scalar. That is, you can think of * as having one of the the following types:

(*) :: Rational -> Dense currency -> Dense currency

(*) :: Dense currency -> Rational -> Dense currency@

That is:

dense' (1 % 4) * dense' (1 % 2)  ==  dense' (1 % 8)

In fact, if you compiled this library with support for VectorSpace, then * functions exactly as *^.

(*)  ==  (*^)

(*)  ==  flip (*^)

Methods

(+) :: Dense currency -> Dense currency -> Dense currency

(-) :: Dense currency -> Dense currency -> Dense currency

(*) :: Dense currency -> Dense currency -> Dense currency

negate :: Dense currency -> Dense currency

abs :: Dense currency -> Dense currency

signum :: Dense currency -> Dense currency

fromInteger :: Integer -> Dense currency

Ord (Dense currency)

Methods

compare :: Dense currency -> Dense currency -> Ordering

(<) :: Dense currency -> Dense currency -> Bool

(<=) :: Dense currency -> Dense currency -> Bool

(>) :: Dense currency -> Dense currency -> Bool

(>=) :: Dense currency -> Dense currency -> Bool

max :: Dense currency -> Dense currency -> Dense currency

min :: Dense currency -> Dense currency -> Dense currency

KnownSymbol currency => Read (Dense currency)

Methods

readsPrec :: Int -> ReadS (Dense currency)

readList :: ReadS [Dense currency]

readPrec :: ReadPrec (Dense currency)

readListPrec :: ReadPrec [Dense currency]

Real (Dense currency)

Methods

toRational :: Dense currency -> Rational

KnownSymbol currency => Show (Dense currency)

> show (dense' (1 % 3) :: Dense "USD")
"Dense \"USD\" 1%3"

Methods

showsPrec :: Int -> Dense currency -> ShowS

show :: Dense currency -> String

showList :: [Dense currency] -> ShowS

Generic (Dense currency)

Associated Types

type Rep (Dense currency) :: * -> *

Methods

from :: Dense currency -> Rep (Dense currency) x

to :: Rep (Dense currency) x -> Dense currency

Hashable (Dense currency)

Methods

hashWithSalt :: Int -> Dense currency -> Int

hash :: Dense currency -> Int

KnownSymbol currency => ToJSON (Dense currency)

Compatible with SomeDense

Example rendering dense' (2 % 3) :: Dense "BTC":

["BTC", 2, 3]

Note: The JSON serialization changed in version 0.4 (the leading Dense string was dropped from the rendered Array).

Methods

toJSON :: Dense currency -> Value

toEncoding :: Dense currency -> Encoding

toJSONList :: [Dense currency] -> Value

toEncodingList :: [Dense currency] -> Encoding

KnownSymbol currency => FromJSON (Dense currency)

Compatible with SomeDense

Note: The JSON serialization changed in version 0.4. However, this instance is still able to cope with the previous format.

Methods

parseJSON :: Value -> Parser (Dense currency)

parseJSONList :: Value -> Parser [Dense currency]

KnownSymbol currency => Binary (Dense currency)

Compatible with SomeDense.

Methods

put :: Dense currency -> Put

get :: Get (Dense currency)

putList :: [Dense currency] -> Put

KnownSymbol currency => Serialize (Dense currency)

Compatible with SomeDense.

Methods

put :: Putter (Dense currency)

get :: Get (Dense currency)

NFData (Dense currency)

Methods

rnf :: Dense currency -> ()

KnownSymbol currency => Serialise (Dense currency)

Compatible with SomeDense.

Methods

encode :: Dense currency -> Encoding

decode :: Decoder s (Dense currency)

encodeList :: [Dense currency] -> Encoding

decodeList :: Decoder s [Dense currency]

KnownSymbol currency => Store (Dense currency)

Compatible with SomeDense.

Methods

size :: Size (Dense currency)

poke :: Dense currency -> Poke ()

peek :: Peek (Dense currency)

VectorSpace (Dense currency)

WARNING a scalar with a zero denominator will cause *^ to crash.

Associated Types

type Scalar (Dense currency) :: *

Methods

(*^) :: Scalar (Dense currency) -> Dense currency -> Dense currency

AdditiveGroup (Dense currency)

Methods

zeroV :: Dense currency

(^+^) :: Dense currency -> Dense currency -> Dense currency

negateV :: Dense currency -> Dense currency

(^-^) :: Dense currency -> Dense currency -> Dense currency

KnownSymbol currency => FromXml (Dense currency)

Compatible with SomeDense

Methods

fromXml :: Parser (Dense currency)

KnownSymbol currency => ToXml (Dense currency)

Compatible with SomeDense

Example rendering dense (2 % 3) :: Dense "BTC":

<money-dense c="BTC" n="2" d="3"/>

Methods

toXml :: Dense currency -> [Node]

type Rep (Dense currency)

type Rep (Dense currency) = D1 * (MetaData "Dense" "Money.Internal" "safe-money-0.6-FGfQdMihXU7686yGAy4rgF" True) (C1 * (MetaCons "Dense" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Rational)))

type Scalar (Dense currency)

type Scalar (Dense currency) = Rational

denseCurrency :: KnownSymbol currency => Dense currency -> Text

Dense currency identifier.

> denseCurrency (dense' 4 :: Dense "USD")
"USD"

dense :: Rational -> Maybe (Dense currency)

Build a Dense monetary value from a Rational value.

For example, if you want to represent USD 12.52316, then you can use:

dense (125316 % 10000)

Notice that dense returns Nothing in case the given Rational's denominator is zero, which although unlikely, it is possible if the Rational was unsafely constructed. When dealing with hardcoded or trusted Rational values, you can use dense' instead of dense which unsafely constructs a Dense.

dense' :: Rational -> Dense currency

Unsafely build a Dense monetary value from a Rational value. Contrary to dense, this function *crashes* if the given Rational has zero as a denominator, which is something very unlikely to happen unless the given Rational was itself unsafely constructed. Other than that, dense and dense' behave the same.

Prefer to use dense when dealing with Rational inputs from untrusted sources.

denominator x /= 0
  ⇒ dense x == Just (dense' x)

denominator x == 0
  ⇒ undefined == dense' x

denseFromDiscrete

Arguments

:: GoodScale scale

=> Discrete' currency scale

-> Dense currency

Convert currency Discrete monetary value into a Dense monetary value.

denseFromDecimal

Arguments

:: Maybe Char

Thousands separator for the integer part, if any (i.e., the ',' in -1,234.56789).

-> Char

Decimal separator (i.e., the '.' in -1,234.56789)

-> Rational

Scale used by the rendered decimal. It is important to get this number correctly, otherwise the resulting Dense amount will be wrong. Please refer to the documentation for denseToDecimal to understand the meaning of this scale.

In summary, this scale will have a value of 1 unless the decimal amount represents a unit other than the main unit for the currency (e.g., cents rather than dollars for USD, or grams rather than troy-ounces for XAU, or millibitcoins rather than bitcoins for BTC).

-> Text

The raw string containing the decimal representation (e.g., "-1,234.56789").

-> Maybe (Dense currency)

Parses a decimal representation of a Dense.

Leading '-' and '+' characters are considered.

denseToDecimal

Arguments

:: Approximation

Approximation to use if necesary in order to fit the Dense amount in as many decimal numbers as requested.

-> Bool

Whether to render a leading '+' sign in case the amount is positive.

-> Maybe Char

Thousands separator for the integer part, if any (i.e., the ',' in 1,234.56789).

If the given separator is a digit, or if it is equal to the decimal separator, then this functions returns Nothing.

-> Char

Decimal separator (i.e., the '.' in 1,234.56789).

If the given separator is a digit, or if it is equal to the thousands separator, then this functions returns Nothing.

-> Word8

Number of decimal numbers to render, if any.

-> Rational

Scale used to when rendering the decimal number. This is useful if you want to render a “number of cents” rather than a “number of dollars” when rendering a USD amount, for example.

Set this to 1 % 1 if you don't care.

For example, when rendering render dense' (123 % 100) :: Dense USD as a decimal number with three decimal places, a scale of 1 % 1 (analogous to Scale "USD" "dollar") would render 1 as the integer part and 230 as the fractional part, whereas a scale of 100 % 1 (analogous Scale "USD" "cent") would render 123 as the integer part and 000 as the fractional part.

You can easily obtain the scale for a particular currency and unit combination using the scale function. Otherwise, you are free to pass in any other positive Rational number. If a non-positive scale is given, then this function returns Nothing.

Specifying scales other than 1 % 1 is particularly useful for currencies whose main unit is too big. For example, the main unit of gold (XAU) is the troy-ounce, which is too big for day to day accounting, so using the gram or the grain as the unit when rendering decimal amounts could be useful.

Be careful when using a scale smaller than 1 % 1, since it may become impossible to parse back a meaningful amount from the rendered decimal representation unless a big number of fractional digits is used.

-> Dense currency

The dense monetary amount to render.

-> Maybe Text

Returns Nothing is the given separators are not acceptable (i.e., they are digits, or they are equal).

Render a Dense monetary amount as a decimal number in a potentially lossy manner.

> denseToDecimal Round True (Just ',') '.' 2 (1 % 1)
     (dense' (123456 % 100) :: Dense "USD")
Just "+1,234.56"

> denseToDecimal Round True (Just ',') '.' 2 (100 % 1)
     (dense' (123456 % 100) :: Dense "USD")
Just "+123,456.00"

This function returns Nothing if the scale is less than 1, or if it's not possible to reliably render the decimal string due to a bad choice of separators. That is, if the separators are digits or equal among themselves, this function returns Nothing.

Discrete monetary values

type Discrete (currency :: Symbol) (unit :: Symbol) = Discrete' currency (Scale currency unit)

Discrete represents a discrete monetary value for a currency expresed as an integer amount of a particular unit. For example, with currency ~ "USD" and unit ~ "cent" you can represent United States Dollars to their full extent.

currency is usually a ISO-4217 currency code, but not necessarily.

Construct Discrete values using discrete, fromIntegral, fromInteger, discreteFromDense, discreteFromDecimal.

For example, if you want to represent GBP 21.05, where the smallest represetable unit for a GBP (United Kingdom Pound) is the penny, and 100 pennies equal 1 GBP (i.e., Scale "GBP" ~ '(100, 1)), then you can use:

discrete 2105 :: Discrete "GBP" "penny"

Because 2015 / 100 == 20.15.

data Discrete' (currency :: Symbol) (scale :: (Nat, Nat))

Discrete' represents a discrete monetary value for a currency expresed as amount of scale, which is a rational number expressed as (numerator, denominator).

You'll be using Discrete instead of Discrete' most of the time, which mentions the unit name (such as cent or centavo) instead of explicitely mentioning the unit scale.

Instances

GoodScale scale => Enum (Discrete' currency scale)

Methods

succ :: Discrete' currency scale -> Discrete' currency scale

pred :: Discrete' currency scale -> Discrete' currency scale

toEnum :: Int -> Discrete' currency scale

fromEnum :: Discrete' currency scale -> Int

enumFrom :: Discrete' currency scale -> [Discrete' currency scale]

enumFromThen :: Discrete' currency scale -> Discrete' currency scale -> [Discrete' currency scale]

enumFromTo :: Discrete' currency scale -> Discrete' currency scale -> [Discrete' currency scale]

enumFromThenTo :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale -> [Discrete' currency scale]

GoodScale scale => Eq (Discrete' currency scale)

Methods

(==) :: Discrete' currency scale -> Discrete' currency scale -> Bool

(/=) :: Discrete' currency scale -> Discrete' currency scale -> Bool

(ErrFractionalDiscrete, GoodScale scale) => Fractional (Discrete' currency scale)

Methods

(/) :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

recip :: Discrete' currency scale -> Discrete' currency scale

fromRational :: Rational -> Discrete' currency scale

GoodScale scale => Integral (Discrete' currency scale)

Methods

quot :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

rem :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

div :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

mod :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

quotRem :: Discrete' currency scale -> Discrete' currency scale -> (Discrete' currency scale, Discrete' currency scale)

divMod :: Discrete' currency scale -> Discrete' currency scale -> (Discrete' currency scale, Discrete' currency scale)

toInteger :: Discrete' currency scale -> Integer

GoodScale scale => Num (Discrete' currency scale)

Notice that multiplication of Discrete' values doesn't make sense:

(*) :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

How is * implemented, then? It behaves as the scalar multiplication of a Discrete' amount by an Integer scalar. That is, you can think of * as having one of the the following types:

(*) :: Integer -> Discrete' currency scale -> Discrete' currency scale

(*) :: Discrete' currency scale -> Integer -> Discrete' currency scale@

That is:

discrete 2 * discrete 4  ==  discrete 8

In fact, if you compiled this library with support for VectorSpace, then * functions exactly as *^.

(*)  ==  (*^)

(*)  ==  flip (*^)

Methods

(+) :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

(-) :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

(*) :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

negate :: Discrete' currency scale -> Discrete' currency scale

abs :: Discrete' currency scale -> Discrete' currency scale

signum :: Discrete' currency scale -> Discrete' currency scale

fromInteger :: Integer -> Discrete' currency scale

GoodScale scale => Ord (Discrete' currency scale)

Methods

compare :: Discrete' currency scale -> Discrete' currency scale -> Ordering

(<) :: Discrete' currency scale -> Discrete' currency scale -> Bool

(<=) :: Discrete' currency scale -> Discrete' currency scale -> Bool

(>) :: Discrete' currency scale -> Discrete' currency scale -> Bool

(>=) :: Discrete' currency scale -> Discrete' currency scale -> Bool

max :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

min :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

(KnownSymbol currency, GoodScale scale) => Read (Discrete' currency scale)

Methods

readsPrec :: Int -> ReadS (Discrete' currency scale)

readList :: ReadS [Discrete' currency scale]

readPrec :: ReadPrec (Discrete' currency scale)

readListPrec :: ReadPrec [Discrete' currency scale]

GoodScale scale => Real (Discrete' currency scale)

Methods

toRational :: Discrete' currency scale -> Rational

(KnownSymbol currency, GoodScale scale) => Show (Discrete' currency scale)

> show (discrete 123 :: Discrete "USD" "cent")
"Discrete \"USD\" 100%1 123"

Methods

showsPrec :: Int -> Discrete' currency scale -> ShowS

show :: Discrete' currency scale -> String

showList :: [Discrete' currency scale] -> ShowS

GoodScale scale => Generic (Discrete' currency scale)

Associated Types

type Rep (Discrete' currency scale) :: * -> *

Methods

from :: Discrete' currency scale -> Rep (Discrete' currency scale) x

to :: Rep (Discrete' currency scale) x -> Discrete' currency scale

GoodScale scale => Hashable (Discrete' currency scale)

Methods

hashWithSalt :: Int -> Discrete' currency scale -> Int

hash :: Discrete' currency scale -> Int

(KnownSymbol currency, GoodScale scale) => ToJSON (Discrete' currency scale)

Compatible with SomeDiscrete

Example rendering discrete 43 :: Discrete "BTC" "satoshi":

["BTC", 100000000, 1, 43]

Note: The JSON serialization changed in version 0.4 (the leading Discrete string was dropped from the rendered Array).

Methods

toJSON :: Discrete' currency scale -> Value

toEncoding :: Discrete' currency scale -> Encoding

toJSONList :: [Discrete' currency scale] -> Value

toEncodingList :: [Discrete' currency scale] -> Encoding

(KnownSymbol currency, GoodScale scale) => FromJSON (Discrete' currency scale)

Compatible with SomeDiscrete

Note: The JSON serialization changed in version 0.4. However, this instance is still able to cope with the previous format.

Methods

parseJSON :: Value -> Parser (Discrete' currency scale)

parseJSONList :: Value -> Parser [Discrete' currency scale]

(KnownSymbol currency, GoodScale scale) => Binary (Discrete' currency scale)

Compatible with SomeDiscrete.

Methods

put :: Discrete' currency scale -> Put

get :: Get (Discrete' currency scale)

putList :: [Discrete' currency scale] -> Put

(KnownSymbol currency, GoodScale scale) => Serialize (Discrete' currency scale)

Compatible with SomeDiscrete.

Methods

put :: Putter (Discrete' currency scale)

get :: Get (Discrete' currency scale)

GoodScale scale => NFData (Discrete' currency scale)

Methods

rnf :: Discrete' currency scale -> ()

(KnownSymbol currency, GoodScale scale) => Serialise (Discrete' currency scale)

Compatible with SomeDiscrete.

Methods

encode :: Discrete' currency scale -> Encoding

decode :: Decoder s (Discrete' currency scale)

encodeList :: [Discrete' currency scale] -> Encoding

decodeList :: Decoder s [Discrete' currency scale]

(KnownSymbol currency, GoodScale scale) => Store (Discrete' currency scale)

Compatible with SomeDiscrete.

Methods

size :: Size (Discrete' currency scale)

poke :: Discrete' currency scale -> Poke ()

peek :: Peek (Discrete' currency scale)

GoodScale scale => VectorSpace (Discrete' currency scale)

Associated Types

type Scalar (Discrete' currency scale) :: *

Methods

(*^) :: Scalar (Discrete' currency scale) -> Discrete' currency scale -> Discrete' currency scale

GoodScale scale => AdditiveGroup (Discrete' currency scale)

Methods

zeroV :: Discrete' currency scale

(^+^) :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

negateV :: Discrete' currency scale -> Discrete' currency scale

(^-^) :: Discrete' currency scale -> Discrete' currency scale -> Discrete' currency scale

(KnownSymbol currency, GoodScale scale) => FromXml (Discrete' currency scale)

Compatible with SomeDiscrete

Methods

fromXml :: Parser (Discrete' currency scale)

(KnownSymbol currency, GoodScale scale) => ToXml (Discrete' currency scale)

Compatible with SomeDiscrete

Example rendering discrete 43 :: Discrete "BTC" "satoshi":

<money-discrete c="BTC" n="100000000" d="1" a="43"/>

Methods

toXml :: Discrete' currency scale -> [Node]

type Rep (Discrete' currency scale)

type Rep (Discrete' currency scale) = D1 * (MetaData "Discrete'" "Money.Internal" "safe-money-0.6-FGfQdMihXU7686yGAy4rgF" True) (C1 * (MetaCons "Discrete" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Integer)))

type Scalar (Discrete' currency scale)

type Scalar (Discrete' currency scale) = Integer

discrete :: GoodScale scale => Integer -> Discrete' currency scale

Construct a Discrete value.

discreteCurrency

Arguments

:: (KnownSymbol currency, GoodScale scale)

=> Discrete' currency scale

-> Text

Discrete currency identifier.

> discreteCurrency (discrete 4 :: Discrete "USD" "cent")
"USD"

discreteFromDense

Arguments

:: GoodScale scale

=> Approximation

Approximation to use if necesary in order to fit the Dense amount in the requested scale.

-> Dense currency

-> (Discrete' currency scale, Dense currency)

Approximate a Dense value x to the nearest value fully representable a given scale.

If the given Dense doesn't fit entirely in the scale, then a non-zero Dense reminder is returned alongside the Discrete approximation.

Proof that discreteFromDense doesn't lose money:

x == case discreteFromDense a x of
        (y, z) -> denseFromDiscrete y + z

discreteFromDecimal

Arguments

:: GoodScale scale

=> Maybe Char

Thousands separator for the integer part, if any (i.e., the ',' in -1,234.56789).

-> Char

Decimal separator (i.e., the '.' in -1,234.56789)

-> Rational

Scale used by the rendered decimal. It is important to get this number correctly, otherwise the resulting Dense amount will be wrong. Please refer to the documentation for denseToDecimal to understand the meaning of this scale.

In summary, this scale will have a value of 1 unless the decimal amount represents a unit other than the main unit for the currency (e.g., cents rather than dollars for USD, or grams rather than troy-ounces for XAU, or millibitcoins rather than bitcoins for BTC).

-> Text

The raw string containing the decimal representation (e.g., "-1,234.56789").

-> Maybe (Discrete' currency scale)

Parses a decimal representation of a Discrete.

Leading '-' and '+' characters are considered.

Notice that parsing will fail unless the entire precision of the decimal number can be represented in the desired scale.

discreteToDecimal

Arguments

:: GoodScale scale

=> Approximation

Approximation to use if necesary in order to fit the Discrete amount in as many decimal numbers as requested.

-> Bool

Whether to render a leading '+' sign in case the amount is positive.

-> Maybe Char

Thousands separator for the integer part, if any (i.e., the ',' in 1,234.56789).

If the given separator is a digit, or if it is equal to the decimal separator, then this functions returns Nothing.

-> Char

Decimal separator (i.e., the '.' in 1,234.56789).

If the given separator is a digit, or if it is equal to the thousands separator, then this functions returns Nothing.

-> Word8

Number of decimal numbers to render, if any.

-> Rational

Scale used to when rendering the decimal number. This is useful if you want to render a “number of cents” rather than a “number of dollars” when rendering a USD amount, for example.

Set this to 1 % 1 if you don't care.

For example, when rendering render discrete 123 :: Dense "USD" "cent" as a decimal number with three decimal places, a scale of 1 % 1 (analogous to Scale "USD" "dollar") would render 1 as the integer part and 230 as the fractional part, whereas a scale of 100 % 1 (analogous Scale "USD" "cent") would render 123 as the integer part and 000 as the fractional part.

You can easily obtain the scale for a particular currency and unit combination using the scale function. Otherwise, you are free to pass in any other positive Rational number. If a non-positive scale is given, then this function returns Nothing.

Specifying scales other than 1 % 1 is particularly useful for currencies whose main unit is too big. For example, the main unit of gold (XAU) is the troy-ounce, which is too big for day to day accounting, so using the gram or the grain as the unit when rendering decimal amounts could be useful.

Be careful when using a scale smaller than 1 % 1, since it may become impossible to parse back a meaningful amount from the rendered decimal representation unless a big number of fractional digits is used.

-> Discrete' currency scale

The monetary amount to render.

-> Maybe Text

Returns Nothing is the given separators are not acceptable (i.e., they are digits, or they are equal).

Render a Discrete' monetary amount as a decimal number in a potentially lossy manner.

This is simply a convenient wrapper around denseToDecimal:

discreteToDecimal a b c d e f (dis :: Discrete' currency scale)
    == denseToDecimal a b c d e f (denseFromDiscrete dis :: Dense currency)

In particular, the scale in Discrete' currency scale has no influence over the scale in which the decimal number is rendered. Use the Rational parameter to this function for modifying that behavior.

Please refer to denseToDecimal for further documentation.

This function returns Nothing if the scale is less than 1, or if it's not possible to reliably render the decimal string due to a bad choice of separators. That is, if the separators are digits or equal among themselves, this function returns Nothing.

Currency scales

type family Scale (currency :: Symbol) (unit :: Symbol) :: (Nat, Nat)

Scale currency unit is an rational number (expressed as '(numerator, denominator)) indicating how many pieces of unit fit in currency.

currency is usually a ISO-4217 currency code, but not necessarily.

The Scale will determine how to convert a Dense value into a Discrete value and vice-versa.

For example, there are 100 USD cents in 1 USD, so the scale for this relationship is:

type instance Scale "USD" "cent" = '(100, 1)

As another example, there is 1 dollar in USD, so the scale for this relationship is:

type instance Scale "USD" "dollar" = '(1, 1)

When using Discrete values to represent money, it will be impossible to represent an amount of currency smaller than unit. So, if you decide to use Scale "USD" "dollar" as your scale, you will not be able to represent values such as USD 3.50 or USD 21.87 becacuse they are not exact multiples of a dollar.

If there exists a canonical smallest unit that can fully represent the currency in all its denominations, then an instance Scale currency currency exists.

type instance Scale "USD" "USD" = Scale "USD" "cent"

For some monetary values, such as precious metals, there is no smallest representable unit, since you can repeatedly split the precious metal many times before it stops being a precious metal. Nevertheless, for practical purposes we can make a sane arbitrary choice of smallest unit. For example, the base unit for XAU (Gold) is the troy ounce, which is too big to be considered the smallest unit, but we can arbitrarily choose the milligrain as our smallest unit, which is about as heavy as a single grain of table salt and should be sufficiently precise for all monetary practical purposes. A troy ounce equals 480000 milligrains.

type instance Scale "XAU" "milligrain" = '(480000, 1)

You can use other units such as milligrams for measuring XAU, for example. However, since the amount of milligrams in a troy ounce (31103.477) is not integral, we need to use rational with a denominator different than 1 to express it.

type instance Scale "XAU" "milligram" = '(31103477, 1000)

If you try to obtain the Scale of a currency without an obvious smallest representable unit, like XAU, you will get a compile error.

Instances

type Scale "ADA" "ADA"

type Scale "ADA" "ADA" = (,) Nat Nat 1000000 1

type Scale "ADA" "ada"

type Scale "ADA" "ada" = (,) Nat Nat 1 1

type Scale "ADA" "lovelace"

type Scale "ADA" "lovelace" = (,) Nat Nat 1000000 1

type Scale "AED" "AED"

type Scale "AED" "AED" = (,) Nat Nat 100 1

type Scale "AED" "dirham"

type Scale "AED" "dirham" = (,) Nat Nat 1 1

type Scale "AED" "fils"

type Scale "AED" "fils" = (,) Nat Nat 100 1

type Scale "AFN" "AFN"

type Scale "AFN" "AFN" = (,) Nat Nat 100 1

type Scale "AFN" "afghani"

type Scale "AFN" "afghani" = (,) Nat Nat 1 1

type Scale "AFN" "pul"

type Scale "AFN" "pul" = (,) Nat Nat 100 1

type Scale "ALL" "ALL"

type Scale "ALL" "ALL" = (,) Nat Nat 100 1

type Scale "ALL" "lek"

type Scale "ALL" "lek" = (,) Nat Nat 1 1

type Scale "ALL" "qindarke"

type Scale "ALL" "qindarke" = (,) Nat Nat 100 1

type Scale "AMD" "AMD"

type Scale "AMD" "AMD" = (,) Nat Nat 100 1

type Scale "AMD" "dram"

type Scale "AMD" "dram" = (,) Nat Nat 1 1

type Scale "AMD" "luma"

type Scale "AMD" "luma" = (,) Nat Nat 100 1

type Scale "ANG" "ANG"

type Scale "ANG" "ANG" = (,) Nat Nat 100 1

type Scale "ANG" "cent"

type Scale "ANG" "cent" = (,) Nat Nat 100 1

type Scale "ANG" "guilder"

type Scale "ANG" "guilder" = (,) Nat Nat 1 1

type Scale "AOA" "AOA"

type Scale "AOA" "AOA" = (,) Nat Nat 100 1

type Scale "AOA" "centimo"

type Scale "AOA" "centimo" = (,) Nat Nat 100 1

type Scale "AOA" "kwanza"

type Scale "AOA" "kwanza" = (,) Nat Nat 1 1

type Scale "ARS" "ARS"

type Scale "ARS" "ARS" = (,) Nat Nat 100 1

type Scale "ARS" "centavo"

type Scale "ARS" "centavo" = (,) Nat Nat 100 1

type Scale "ARS" "peso"

type Scale "ARS" "peso" = (,) Nat Nat 1 1

type Scale "AUD" "AUD"

type Scale "AUD" "AUD" = (,) Nat Nat 100 1

type Scale "AUD" "cent"

type Scale "AUD" "cent" = (,) Nat Nat 100 1

type Scale "AUD" "dollar"

type Scale "AUD" "dollar" = (,) Nat Nat 1 1

type Scale "AWG" "AWG"

type Scale "AWG" "AWG" = (,) Nat Nat 100 1

type Scale "AWG" "cent"

type Scale "AWG" "cent" = (,) Nat Nat 100 1

type Scale "AWG" "florin"

type Scale "AWG" "florin" = (,) Nat Nat 1 1

type Scale "AZN" "AZN"

type Scale "AZN" "AZN" = (,) Nat Nat 100 1

type Scale "AZN" "manat"

type Scale "AZN" "manat" = (,) Nat Nat 1 1

type Scale "AZN" "qapik"

type Scale "AZN" "qapik" = (,) Nat Nat 100 1

type Scale "BAM" "BAM"

type Scale "BAM" "BAM" = (,) Nat Nat 100 1

type Scale "BAM" "fening"

type Scale "BAM" "fening" = (,) Nat Nat 100 1

type Scale "BAM" "mark"

type Scale "BAM" "mark" = (,) Nat Nat 1 1

type Scale "BBD" "BBD"

type Scale "BBD" "BBD" = (,) Nat Nat 100 1

type Scale "BBD" "cent"

type Scale "BBD" "cent" = (,) Nat Nat 100 1

type Scale "BBD" "dollar"

type Scale "BBD" "dollar" = (,) Nat Nat 1 1

type Scale "BDT" "BDT"

type Scale "BDT" "BDT" = (,) Nat Nat 100 1

type Scale "BDT" "paisa"

type Scale "BDT" "paisa" = (,) Nat Nat 100 1

type Scale "BDT" "taka"

type Scale "BDT" "taka" = (,) Nat Nat 1 1

type Scale "BGN" "BGN"

type Scale "BGN" "BGN" = (,) Nat Nat 100 1

type Scale "BGN" "lev"

type Scale "BGN" "lev" = (,) Nat Nat 1 1

type Scale "BGN" "stotinka"

type Scale "BGN" "stotinka" = (,) Nat Nat 100 1

type Scale "BHD" "BHD"

type Scale "BHD" "BHD" = (,) Nat Nat 1000 1

type Scale "BHD" "dinar"

type Scale "BHD" "dinar" = (,) Nat Nat 1 1

type Scale "BHD" "fils"

type Scale "BHD" "fils" = (,) Nat Nat 1000 1

type Scale "BIF" "BIF"

type Scale "BIF" "BIF" = (,) Nat Nat 100 1

type Scale "BIF" "centime"

type Scale "BIF" "centime" = (,) Nat Nat 100 1

type Scale "BIF" "franc"

type Scale "BIF" "franc" = (,) Nat Nat 1 1

type Scale "BMD" "BMD"

type Scale "BMD" "BMD" = (,) Nat Nat 100 1

type Scale "BMD" "cent"

type Scale "BMD" "cent" = (,) Nat Nat 100 1

type Scale "BMD" "dollar"

type Scale "BMD" "dollar" = (,) Nat Nat 1 1

type Scale "BND" "BND"

type Scale "BND" "BND" = (,) Nat Nat 100 1

type Scale "BND" "dollar"

type Scale "BND" "dollar" = (,) Nat Nat 1 1

type Scale "BND" "sen"

type Scale "BND" "sen" = (,) Nat Nat 100 1

type Scale "BOB" "BOB"

type Scale "BOB" "BOB" = (,) Nat Nat 100 1

type Scale "BOB" "boliviano"

type Scale "BOB" "boliviano" = (,) Nat Nat 1 1

type Scale "BOB" "centavo"

type Scale "BOB" "centavo" = (,) Nat Nat 100 1

type Scale "BOV" "BOV"

type Scale "BOV" "BOV" = (,) Nat Nat 100 1

type Scale "BRL" "BRL"

type Scale "BRL" "BRL" = (,) Nat Nat 100 1

type Scale "BRL" "centavo"

type Scale "BRL" "centavo" = (,) Nat Nat 100 1

type Scale "BRL" "real"

type Scale "BRL" "real" = (,) Nat Nat 1 1

type Scale "BSD" "BSD"

type Scale "BSD" "BSD" = (,) Nat Nat 100 1

type Scale "BSD" "cent"

type Scale "BSD" "cent" = (,) Nat Nat 1 1

type Scale "BSD" "dollar"

type Scale "BSD" "dollar" = (,) Nat Nat 1 1

type Scale "BTC" "BTC"

type Scale "BTC" "BTC" = (,) Nat Nat 100000000 1

type Scale "BTC" "bitcoin"

type Scale "BTC" "bitcoin" = (,) Nat Nat 1 1

type Scale "BTC" "millibitcoin"

type Scale "BTC" "millibitcoin" = (,) Nat Nat 1000 1

type Scale "BTC" "satoshi"

type Scale "BTC" "satoshi" = (,) Nat Nat 100000000 1

type Scale "BTN" "BTN"

type Scale "BTN" "BTN" = (,) Nat Nat 100 1

type Scale "BTN" "chetrum"

type Scale "BTN" "chetrum" = (,) Nat Nat 100 1

type Scale "BTN" "ngultrum"

type Scale "BTN" "ngultrum" = (,) Nat Nat 1 1

type Scale "BWP" "BWP"

type Scale "BWP" "BWP" = (,) Nat Nat 100 1

type Scale "BWP" "pula"

type Scale "BWP" "pula" = (,) Nat Nat 1 1

type Scale "BWP" "thebe"

type Scale "BWP" "thebe" = (,) Nat Nat 100 1

type Scale "BYN" "BYN"

type Scale "BYN" "BYN" = (,) Nat Nat 100 1

type Scale "BYR" "BYR"

type Scale "BYR" "BYR" = (,) Nat Nat 100 1

type Scale "BYR" "kapyeyka"

type Scale "BYR" "kapyeyka" = (,) Nat Nat 100 1

type Scale "BYR" "ruble"

type Scale "BYR" "ruble" = (,) Nat Nat 1 1

type Scale "BZD" "BZD"

type Scale "BZD" "BZD" = (,) Nat Nat 100 1

type Scale "BZD" "cent"

type Scale "BZD" "cent" = (,) Nat Nat 100 1

type Scale "BZD" "dollar"

type Scale "BZD" "dollar" = (,) Nat Nat 1 1

type Scale "CAD" "CAD"

type Scale "CAD" "CAD" = (,) Nat Nat 100 1

type Scale "CAD" "cent"

type Scale "CAD" "cent" = (,) Nat Nat 100 1

type Scale "CAD" "dollar"

type Scale "CAD" "dollar" = (,) Nat Nat 1 1

type Scale "CDF" "CDF"

type Scale "CDF" "CDF" = (,) Nat Nat 100 1

type Scale "CDF" "centime"

type Scale "CDF" "centime" = (,) Nat Nat 100 1

type Scale "CDF" "franc"

type Scale "CDF" "franc" = (,) Nat Nat 1 1

type Scale "CHE" "CHE"

type Scale "CHE" "CHE" = (,) Nat Nat 100 1

type Scale "CHF" "CHF"

type Scale "CHF" "CHF" = (,) Nat Nat 100 1

type Scale "CHF" "franc"

type Scale "CHF" "franc" = (,) Nat Nat 1 1

type Scale "CHF" "rappen"

type Scale "CHF" "rappen" = (,) Nat Nat 100 1

type Scale "CHW" "CHW"

type Scale "CHW" "CHW" = (,) Nat Nat 100 1

type Scale "CLF" "CLF"

type Scale "CLF" "CLF" = (,) Nat Nat 100 1

type Scale "CLP" "CLP"

type Scale "CLP" "CLP" = (,) Nat Nat 100 1

type Scale "CLP" "centavo"

type Scale "CLP" "centavo" = (,) Nat Nat 100 1

type Scale "CLP" "peso"

type Scale "CLP" "peso" = (,) Nat Nat 1 1

type Scale "CNY" "CNY"

type Scale "CNY" "CNY" = (,) Nat Nat 100 1

type Scale "CNY" "fen"

type Scale "CNY" "fen" = (,) Nat Nat 100 1

type Scale "CNY" "yuan"

type Scale "CNY" "yuan" = (,) Nat Nat 1 1

type Scale "COP" "COP"

type Scale "COP" "COP" = (,) Nat Nat 100 1

type Scale "COP" "centavo"

type Scale "COP" "centavo" = (,) Nat Nat 100 1

type Scale "COP" "peso"

type Scale "COP" "peso" = (,) Nat Nat 1 1

type Scale "COU" "COU"

type Scale "COU" "COU" = (,) Nat Nat 100 1

type Scale "CRC" "CRC"

type Scale "CRC" "CRC" = (,) Nat Nat 100 1

type Scale "CRC" "centimo"

type Scale "CRC" "centimo" = (,) Nat Nat 100 1

type Scale "CRC" "colon"

type Scale "CRC" "colon" = (,) Nat Nat 1 1

type Scale "CUC" "CUC"

type Scale "CUC" "CUC" = (,) Nat Nat 100 1

type Scale "CUC" "centavo"

type Scale "CUC" "centavo" = (,) Nat Nat 100 1

type Scale "CUC" "peso"

type Scale "CUC" "peso" = (,) Nat Nat 1 1

type Scale "CUP" "CUP"

type Scale "CUP" "CUP" = (,) Nat Nat 100 1

type Scale "CUP" "centavo"

type Scale "CUP" "centavo" = (,) Nat Nat 100 1

type Scale "CUP" "peso"

type Scale "CUP" "peso" = (,) Nat Nat 1 1

type Scale "CVE" "CVE"

type Scale "CVE" "CVE" = (,) Nat Nat 100 1

type Scale "CVE" "centavo"

type Scale "CVE" "centavo" = (,) Nat Nat 100 1

type Scale "CVE" "escudo"

type Scale "CVE" "escudo" = (,) Nat Nat 1 1

type Scale "CZK" "CZK"

type Scale "CZK" "CZK" = (,) Nat Nat 100 1

type Scale "CZK" "haler"

type Scale "CZK" "haler" = (,) Nat Nat 100 1

type Scale "CZK" "koruna"

type Scale "CZK" "koruna" = (,) Nat Nat 1 1

type Scale "DJF" "DJF"

type Scale "DJF" "DJF" = (,) Nat Nat 100 1

type Scale "DJF" "centime"

type Scale "DJF" "centime" = (,) Nat Nat 100 1

type Scale "DJF" "franc"

type Scale "DJF" "franc" = (,) Nat Nat 1 1

type Scale "DKK" "DKK"

type Scale "DKK" "DKK" = (,) Nat Nat 100 1

type Scale "DKK" "krone"

type Scale "DKK" "krone" = (,) Nat Nat 1 1

type Scale "DKK" "ore"

type Scale "DKK" "ore" = (,) Nat Nat 100 1

type Scale "DOP" "DOP"

type Scale "DOP" "DOP" = (,) Nat Nat 100 1

type Scale "DOP" "centavo"

type Scale "DOP" "centavo" = (,) Nat Nat 100 1

type Scale "DOP" "peso"

type Scale "DOP" "peso" = (,) Nat Nat 1 1

type Scale "DZD" "DZD"

type Scale "DZD" "DZD" = (,) Nat Nat 100 1

type Scale "DZD" "dinar"

type Scale "DZD" "dinar" = (,) Nat Nat 1 1

type Scale "DZD" "santeem"

type Scale "DZD" "santeem" = (,) Nat Nat 100 1

type Scale "EGP" "EGP"

type Scale "EGP" "EGP" = (,) Nat Nat 100 1

type Scale "EGP" "piastre"

type Scale "EGP" "piastre" = (,) Nat Nat 100 1

type Scale "EGP" "pound"

type Scale "EGP" "pound" = (,) Nat Nat 1 1

type Scale "ERN" "ERN"

type Scale "ERN" "ERN" = (,) Nat Nat 100 1

type Scale "ERN" "cent"

type Scale "ERN" "cent" = (,) Nat Nat 100 1

type Scale "ERN" "nafka"

type Scale "ERN" "nafka" = (,) Nat Nat 1 1

type Scale "ETB" "ETB"

type Scale "ETB" "ETB" = (,) Nat Nat 100 1

type Scale "ETB" "birr"

type Scale "ETB" "birr" = (,) Nat Nat 1 1

type Scale "ETB" "santim"

type Scale "ETB" "santim" = (,) Nat Nat 100 1

type Scale "ETH" "ETH"

type Scale "ETH" "ETH" = (,) Nat Nat 1000000000000000000 1

type Scale "ETH" "babbage"

type Scale "ETH" "babbage" = (,) Nat Nat 1000 1

type Scale "ETH" "ether"

type Scale "ETH" "ether" = (,) Nat Nat 1 1

type Scale "ETH" "finney"

type Scale "ETH" "finney" = (,) Nat Nat 1000000000000000 1

type Scale "ETH" "gwei"

type Scale "ETH" "gwei" = (,) Nat Nat 1000000000 1

type Scale "ETH" "kwei"

type Scale "ETH" "kwei" = (,) Nat Nat 1000 1

type Scale "ETH" "lovelace"

type Scale "ETH" "lovelace" = (,) Nat Nat 1000000 1

type Scale "ETH" "microether"

type Scale "ETH" "microether" = (,) Nat Nat 1000000000000 1

type Scale "ETH" "milliether"

type Scale "ETH" "milliether" = (,) Nat Nat 1000000000000000 1

type Scale "ETH" "mwei"

type Scale "ETH" "mwei" = (,) Nat Nat 1000000 1

type Scale "ETH" "shannon"

type Scale "ETH" "shannon" = (,) Nat Nat 1000000000 1

type Scale "ETH" "szabo"

type Scale "ETH" "szabo" = (,) Nat Nat 1000000000000 1

type Scale "ETH" "wei"

type Scale "ETH" "wei" = (,) Nat Nat 1000000000000000000 1

type Scale "EUR" "EUR"

type Scale "EUR" "EUR" = (,) Nat Nat 100 1

type Scale "EUR" "cent"

type Scale "EUR" "cent" = (,) Nat Nat 100 1

type Scale "EUR" "euro"

type Scale "EUR" "euro" = (,) Nat Nat 1 1

type Scale "FJD" "FJD"

type Scale "FJD" "FJD" = (,) Nat Nat 100 1

type Scale "FKP" "FKP"

type Scale "FKP" "FKP" = (,) Nat Nat 100 1

type Scale "FKP" "penny"

type Scale "FKP" "penny" = (,) Nat Nat 100 1

type Scale "FKP" "pound"

type Scale "FKP" "pound" = (,) Nat Nat 1 1

type Scale "GBP" "GBP"

type Scale "GBP" "GBP" = (,) Nat Nat 100 1

type Scale "GBP" "penny"

type Scale "GBP" "penny" = (,) Nat Nat 100 1

type Scale "GBP" "pound"

type Scale "GBP" "pound" = (,) Nat Nat 1 1

type Scale "GEL" "GEL"

type Scale "GEL" "GEL" = (,) Nat Nat 100 1

type Scale "GEL" "lari"

type Scale "GEL" "lari" = (,) Nat Nat 1 1

type Scale "GEL" "tetri"

type Scale "GEL" "tetri" = (,) Nat Nat 100 1

type Scale "GHS" "GHS"

type Scale "GHS" "GHS" = (,) Nat Nat 100 1

type Scale "GHS" "cedi"

type Scale "GHS" "cedi" = (,) Nat Nat 1 1

type Scale "GHS" "pesewa"

type Scale "GHS" "pesewa" = (,) Nat Nat 100 1

type Scale "GIP" "GIP"

type Scale "GIP" "GIP" = (,) Nat Nat 100 1

type Scale "GIP" "penny"

type Scale "GIP" "penny" = (,) Nat Nat 100 1

type Scale "GIP" "pound"

type Scale "GIP" "pound" = (,) Nat Nat 1 1

type Scale "GMD" "GMD"

type Scale "GMD" "GMD" = (,) Nat Nat 100 1

type Scale "GMD" "butut"

type Scale "GMD" "butut" = (,) Nat Nat 100 1

type Scale "GMD" "dalasi"

type Scale "GMD" "dalasi" = (,) Nat Nat 1 1

type Scale "GNF" "GNF"

type Scale "GNF" "GNF" = (,) Nat Nat 100 1

type Scale "GNF" "centime"

type Scale "GNF" "centime" = (,) Nat Nat 100 1

type Scale "GNF" "franc"

type Scale "GNF" "franc" = (,) Nat Nat 1 1

type Scale "GTQ" "GTQ"

type Scale "GTQ" "GTQ" = (,) Nat Nat 100 1

type Scale "GTQ" "centavo"

type Scale "GTQ" "centavo" = (,) Nat Nat 100 1

type Scale "GTQ" "quetzal"

type Scale "GTQ" "quetzal" = (,) Nat Nat 1 1

type Scale "GYD" "GYD"

type Scale "GYD" "GYD" = (,) Nat Nat 100 1

type Scale "GYD" "cent"

type Scale "GYD" "cent" = (,) Nat Nat 100 1

type Scale "GYD" "dollar"

type Scale "GYD" "dollar" = (,) Nat Nat 1 1

type Scale "HKD" "HKD"

type Scale "HKD" "HKD" = (,) Nat Nat 100 1

type Scale "HKD" "cent"

type Scale "HKD" "cent" = (,) Nat Nat 100 1

type Scale "HKD" "dollar"

type Scale "HKD" "dollar" = (,) Nat Nat 1 1

type Scale "HNL" "HNL"

type Scale "HNL" "HNL" = (,) Nat Nat 100 1

type Scale "HNL" "centavo"

type Scale "HNL" "centavo" = (,) Nat Nat 100 1

type Scale "HNL" "lempira"

type Scale "HNL" "lempira" = (,) Nat Nat 1 1

type Scale "HRK" "HRK"

type Scale "HRK" "HRK" = (,) Nat Nat 100 1

type Scale "HRK" "kuna"

type Scale "HRK" "kuna" = (,) Nat Nat 1 1

type Scale "HRK" "lipa"

type Scale "HRK" "lipa" = (,) Nat Nat 100 1

type Scale "HTG" "HTG"

type Scale "HTG" "HTG" = (,) Nat Nat 100 1

type Scale "HTG" "centime"

type Scale "HTG" "centime" = (,) Nat Nat 1 1

type Scale "HTG" "gourde"

type Scale "HTG" "gourde" = (,) Nat Nat 1 1

type Scale "HUF" "HUF"

type Scale "HUF" "HUF" = (,) Nat Nat 100 1

type Scale "HUF" "filler"

type Scale "HUF" "filler" = (,) Nat Nat 100 1

type Scale "HUF" "forint"

type Scale "HUF" "forint" = (,) Nat Nat 1 1

type Scale "IDR" "IDR"

type Scale "IDR" "IDR" = (,) Nat Nat 100 1

type Scale "IDR" "rupiah"

type Scale "IDR" "rupiah" = (,) Nat Nat 1 1

type Scale "IDR" "sen"

type Scale "IDR" "sen" = (,) Nat Nat 100 1

type Scale "ILS" "ILS"

type Scale "ILS" "ILS" = (,) Nat Nat 100 1

type Scale "ILS" "agora"

type Scale "ILS" "agora" = (,) Nat Nat 100 1

type Scale "ILS" "shekel"

type Scale "ILS" "shekel" = (,) Nat Nat 1 1

type Scale "INR" "INR"

type Scale "INR" "INR" = (,) Nat Nat 100 1

type Scale "INR" "paisa"

type Scale "INR" "paisa" = (,) Nat Nat 100 1

type Scale "INR" "rupee"

type Scale "INR" "rupee" = (,) Nat Nat 1 1

type Scale "IQD" "IQD"

type Scale "IQD" "IQD" = (,) Nat Nat 1000 1

type Scale "IQD" "dinar"

type Scale "IQD" "dinar" = (,) Nat Nat 1 1

type Scale "IQD" "fils"

type Scale "IQD" "fils" = (,) Nat Nat 1000 1

type Scale "IRR" "IRR"

type Scale "IRR" "IRR" = (,) Nat Nat 100 1

type Scale "IRR" "dinar"

type Scale "IRR" "dinar" = (,) Nat Nat 100 1

type Scale "IRR" "rial"

type Scale "IRR" "rial" = (,) Nat Nat 1 1

type Scale "ISK" "ISK"

type Scale "ISK" "ISK" = (,) Nat Nat 100 1

type Scale "ISK" "eyrir"

type Scale "ISK" "eyrir" = (,) Nat Nat 100 1

type Scale "ISK" "krona"

type Scale "ISK" "krona" = (,) Nat Nat 1 1

type Scale "JMD" "JMD"

type Scale "JMD" "JMD" = (,) Nat Nat 100 1

type Scale "JMD" "cent"

type Scale "JMD" "cent" = (,) Nat Nat 100 1

type Scale "JMD" "dollar"

type Scale "JMD" "dollar" = (,) Nat Nat 1 1

type Scale "JOD" "JOD"

type Scale "JOD" "JOD" = (,) Nat Nat 100 1

type Scale "JOD" "dinar"

type Scale "JOD" "dinar" = (,) Nat Nat 1 1

type Scale "JOD" "piastre"

type Scale "JOD" "piastre" = (,) Nat Nat 100 1

type Scale "JPY" "JPY"

type Scale "JPY" "JPY" = (,) Nat Nat 100 1

type Scale "JPY" "sen"

type Scale "JPY" "sen" = (,) Nat Nat 100 1

type Scale "JPY" "yen"

type Scale "JPY" "yen" = (,) Nat Nat 1 1

type Scale "KES" "KES"

type Scale "KES" "KES" = (,) Nat Nat 100 1

type Scale "KES" "cent"

type Scale "KES" "cent" = (,) Nat Nat 100 1

type Scale "KES" "shilling"

type Scale "KES" "shilling" = (,) Nat Nat 1 1

type Scale "KGS" "KGS"

type Scale "KGS" "KGS" = (,) Nat Nat 100 1

type Scale "KGS" "som"

type Scale "KGS" "som" = (,) Nat Nat 1 1

type Scale "KGS" "tyiyn"

type Scale "KGS" "tyiyn" = (,) Nat Nat 100 1

type Scale "KHR" "KHR"

type Scale "KHR" "KHR" = (,) Nat Nat 100 1

type Scale "KHR" "riel"

type Scale "KHR" "riel" = (,) Nat Nat 1 1

type Scale "KHR" "sen"

type Scale "KHR" "sen" = (,) Nat Nat 100 1

type Scale "KMF" "KMF"

type Scale "KMF" "KMF" = (,) Nat Nat 100 1

type Scale "KMF" "centime"

type Scale "KMF" "centime" = (,) Nat Nat 100 1

type Scale "KMF" "franc"

type Scale "KMF" "franc" = (,) Nat Nat 1 1

type Scale "KPW" "KPW"

type Scale "KPW" "KPW" = (,) Nat Nat 100 1

type Scale "KPW" "chon"

type Scale "KPW" "chon" = (,) Nat Nat 100 1

type Scale "KPW" "won"

type Scale "KPW" "won" = (,) Nat Nat 1 1

type Scale "KRW" "KRW"

type Scale "KRW" "KRW" = (,) Nat Nat 100 1

type Scale "KRW" "jeon"

type Scale "KRW" "jeon" = (,) Nat Nat 100 1

type Scale "KRW" "won"

type Scale "KRW" "won" = (,) Nat Nat 1 1

type Scale "KWD" "KWD"

type Scale "KWD" "KWD" = (,) Nat Nat 1000 1

type Scale "KWD" "dinar"

type Scale "KWD" "dinar" = (,) Nat Nat 1 1

type Scale "KWD" "fils"

type Scale "KWD" "fils" = (,) Nat Nat 1000 1

type Scale "KYD" "KYD"

type Scale "KYD" "KYD" = (,) Nat Nat 100 1

type Scale "KYD" "cent"

type Scale "KYD" "cent" = (,) Nat Nat 100 1

type Scale "KYD" "dollar"

type Scale "KYD" "dollar" = (,) Nat Nat 1 1

type Scale "KZT" "KZT"

type Scale "KZT" "KZT" = (,) Nat Nat 100 1

type Scale "KZT" "tenge"

type Scale "KZT" "tenge" = (,) Nat Nat 1 1

type Scale "KZT" "tiyin"

type Scale "KZT" "tiyin" = (,) Nat Nat 100 1

type Scale "LAK" "LAK"

type Scale "LAK" "LAK" = (,) Nat Nat 100 1

type Scale "LAK" "att"

type Scale "LAK" "att" = (,) Nat Nat 100 1

type Scale "LAK" "kip"

type Scale "LAK" "kip" = (,) Nat Nat 1 1

type Scale "LBP" "LBP"

type Scale "LBP" "LBP" = (,) Nat Nat 100 1

type Scale "LBP" "piastre"

type Scale "LBP" "piastre" = (,) Nat Nat 100 1

type Scale "LBP" "pound"

type Scale "LBP" "pound" = (,) Nat Nat 1 1

type Scale "LKR" "LKR"

type Scale "LKR" "LKR" = (,) Nat Nat 100 1

type Scale "LKR" "cent"

type Scale "LKR" "cent" = (,) Nat Nat 100 1

type Scale "LKR" "rupee"

type Scale "LKR" "rupee" = (,) Nat Nat 1 1

type Scale "LRD" "LRD"

type Scale "LRD" "LRD" = (,) Nat Nat 100 1

type Scale "LRD" "cent"

type Scale "LRD" "cent" = (,) Nat Nat 100 1

type Scale "LRD" "dollar"

type Scale "LRD" "dollar" = (,) Nat Nat 1 1

type Scale "LSL" "LSL"

type Scale "LSL" "LSL" = (,) Nat Nat 100 1

type Scale "LSL" "loti"

type Scale "LSL" "loti" = (,) Nat Nat 1 1

type Scale "LSL" "sente"

type Scale "LSL" "sente" = (,) Nat Nat 100 1

type Scale "LTC" "LTC"

type Scale "LTC" "LTC" = (,) Nat Nat 100000000 1

type Scale "LTC" "lite"

type Scale "LTC" "lite" = (,) Nat Nat 1000 1

type Scale "LTC" "litecoin"

type Scale "LTC" "litecoin" = (,) Nat Nat 1 1

type Scale "LTC" "photon"

type Scale "LTC" "photon" = (,) Nat Nat 100000000 1

type Scale "LYD" "LYD"

type Scale "LYD" "LYD" = (,) Nat Nat 100 1

type Scale "LYD" "dinar"

type Scale "LYD" "dinar" = (,) Nat Nat 1 1

type Scale "LYD" "dirham"

type Scale "LYD" "dirham" = (,) Nat Nat 1000 1

type Scale "MAD" "MAD"

type Scale "MAD" "MAD" = (,) Nat Nat 100 1

type Scale "MAD" "centime"

type Scale "MAD" "centime" = (,) Nat Nat 100 1

type Scale "MAD" "dirham"

type Scale "MAD" "dirham" = (,) Nat Nat 1 1

type Scale "MDL" "MDL"

type Scale "MDL" "MDL" = (,) Nat Nat 100 1

type Scale "MDL" "ban"

type Scale "MDL" "ban" = (,) Nat Nat 100 1

type Scale "MDL" "leu"

type Scale "MDL" "leu" = (,) Nat Nat 100 1

type Scale "MGA" "MGA"

type Scale "MGA" "MGA" = (,) Nat Nat 5 1

type Scale "MGA" "ariary"

type Scale "MGA" "ariary" = (,) Nat Nat 1 1

type Scale "MGA" "iraimbilanja"

type Scale "MGA" "iraimbilanja" = (,) Nat Nat 5 1

type Scale "MKD" "MKD"

type Scale "MKD" "MKD" = (,) Nat Nat 100 1

type Scale "MKD" "denar"

type Scale "MKD" "denar" = (,) Nat Nat 1 1

type Scale "MKD" "deni"

type Scale "MKD" "deni" = (,) Nat Nat 100 1

type Scale "MMK" "MMK"

type Scale "MMK" "MMK" = (,) Nat Nat 100 1

type Scale "MMK" "kyat"

type Scale "MMK" "kyat" = (,) Nat Nat 1 1

type Scale "MMK" "pya"

type Scale "MMK" "pya" = (,) Nat Nat 100 1

type Scale "MNT" "MNT"

type Scale "MNT" "MNT" = (,) Nat Nat 100 1

type Scale "MNT" "mongo"

type Scale "MNT" "mongo" = (,) Nat Nat 100 1

type Scale "MNT" "tugrik"

type Scale "MNT" "tugrik" = (,) Nat Nat 1 1

type Scale "MOP" "MOP"

type Scale "MOP" "MOP" = (,) Nat Nat 100 1

type Scale "MOP" "avo"

type Scale "MOP" "avo" = (,) Nat Nat 100 1

type Scale "MOP" "pataca"

type Scale "MOP" "pataca" = (,) Nat Nat 1 1

type Scale "MRO" "MRO"

type Scale "MRO" "MRO" = (,) Nat Nat 5 1

type Scale "MRO" "khoums"

type Scale "MRO" "khoums" = (,) Nat Nat 5 1

type Scale "MRO" "ouguiya"

type Scale "MRO" "ouguiya" = (,) Nat Nat 1 1

type Scale "MUR" "MUR"

type Scale "MUR" "MUR" = (,) Nat Nat 100 1

type Scale "MUR" "cent"

type Scale "MUR" "cent" = (,) Nat Nat 100 1

type Scale "MUR" "rupee"

type Scale "MUR" "rupee" = (,) Nat Nat 1 1

type Scale "MVR" "MVR"

type Scale "MVR" "MVR" = (,) Nat Nat 100 1

type Scale "MVR" "laari"

type Scale "MVR" "laari" = (,) Nat Nat 100 1

type Scale "MVR" "rufiyaa"

type Scale "MVR" "rufiyaa" = (,) Nat Nat 1 1

type Scale "MWK" "MWK"

type Scale "MWK" "MWK" = (,) Nat Nat 100 1

type Scale "MWK" "kwacha"

type Scale "MWK" "kwacha" = (,) Nat Nat 1 1

type Scale "MWK" "tambala"

type Scale "MWK" "tambala" = (,) Nat Nat 100 1

type Scale "MXN" "MXN"

type Scale "MXN" "MXN" = (,) Nat Nat 100 1

type Scale "MXN" "centavo"

type Scale "MXN" "centavo" = (,) Nat Nat 100 1

type Scale "MXN" "peso"

type Scale "MXN" "peso" = (,) Nat Nat 1 1

type Scale "MXV" "MXV"

type Scale "MXV" "MXV" = (,) Nat Nat 100 1

type Scale "MYR" "MYR"

type Scale "MYR" "MYR" = (,) Nat Nat 100 1

type Scale "MYR" "ringgit"

type Scale "MYR" "ringgit" = (,) Nat Nat 1 1

type Scale "MYR" "sen"

type Scale "MYR" "sen" = (,) Nat Nat 100 1

type Scale "MZN" "MZN"

type Scale "MZN" "MZN" = (,) Nat Nat 100 1

type Scale "MZN" "centavo"

type Scale "MZN" "centavo" = (,) Nat Nat 100 1

type Scale "MZN" "metical"

type Scale "MZN" "metical" = (,) Nat Nat 1 1

type Scale "NAD" "NAD"

type Scale "NAD" "NAD" = (,) Nat Nat 100 1

type Scale "NAD" "cent"

type Scale "NAD" "cent" = (,) Nat Nat 100 1

type Scale "NAD" "dollar"

type Scale "NAD" "dollar" = (,) Nat Nat 1 1

type Scale "NGN" "NGN"

type Scale "NGN" "NGN" = (,) Nat Nat 100 1

type Scale "NGN" "kobo"

type Scale "NGN" "kobo" = (,) Nat Nat 100 1

type Scale "NGN" "naira"

type Scale "NGN" "naira" = (,) Nat Nat 1 1

type Scale "NIO" "NIO"

type Scale "NIO" "NIO" = (,) Nat Nat 100 1

type Scale "NIO" "centavo"

type Scale "NIO" "centavo" = (,) Nat Nat 100 1

type Scale "NIO" "cordoba"

type Scale "NIO" "cordoba" = (,) Nat Nat 1 1

type Scale "NOK" "NOK"

type Scale "NOK" "NOK" = (,) Nat Nat 100 1

type Scale "NOK" "krone"

type Scale "NOK" "krone" = (,) Nat Nat 1 1

type Scale "NOK" "ore"

type Scale "NOK" "ore" = (,) Nat Nat 100 1

type Scale "NPR" "NPR"

type Scale "NPR" "NPR" = (,) Nat Nat 100 1

type Scale "NPR" "paisa"

type Scale "NPR" "paisa" = (,) Nat Nat 100 1

type Scale "NPR" "rupee"

type Scale "NPR" "rupee" = (,) Nat Nat 1 1

type Scale "NZD" "NZD"

type Scale "NZD" "NZD" = (,) Nat Nat 100 1

type Scale "NZD" "cent"

type Scale "NZD" "cent" = (,) Nat Nat 100 1

type Scale "NZD" "dollar"

type Scale "NZD" "dollar" = (,) Nat Nat 1 1

type Scale "OMR" "OMR"

type Scale "OMR" "OMR" = (,) Nat Nat 1000 1

type Scale "OMR" "baisa"

type Scale "OMR" "baisa" = (,) Nat Nat 1000 1

type Scale "OMR" "rial"

type Scale "OMR" "rial" = (,) Nat Nat 1 1

type Scale "PAB" "PAB"

type Scale "PAB" "PAB" = (,) Nat Nat 100 1

type Scale "PAB" "balboa"

type Scale "PAB" "balboa" = (,) Nat Nat 1 1

type Scale "PAB" "centesimo"

type Scale "PAB" "centesimo" = (,) Nat Nat 100 1

type Scale "PEN" "PEN"

type Scale "PEN" "PEN" = (,) Nat Nat 100 1

type Scale "PEN" "centimo"

type Scale "PEN" "centimo" = (,) Nat Nat 100 1

type Scale "PEN" "sol"

type Scale "PEN" "sol" = (,) Nat Nat 1 1

type Scale "PGK" "PGK"

type Scale "PGK" "PGK" = (,) Nat Nat 100 1

type Scale "PGK" "kina"

type Scale "PGK" "kina" = (,) Nat Nat 1 1

type Scale "PGK" "toea"

type Scale "PGK" "toea" = (,) Nat Nat 100 1

type Scale "PHP" "PHP"

type Scale "PHP" "PHP" = (,) Nat Nat 100 1

type Scale "PHP" "centavo"

type Scale "PHP" "centavo" = (,) Nat Nat 100 1

type Scale "PHP" "peso"

type Scale "PHP" "peso" = (,) Nat Nat 1 1

type Scale "PKR" "PKR"

type Scale "PKR" "PKR" = (,) Nat Nat 100 1

type Scale "PKR" "paisa"

type Scale "PKR" "paisa" = (,) Nat Nat 100 1

type Scale "PKR" "rupee"

type Scale "PKR" "rupee" = (,) Nat Nat 1 1

type Scale "PLN" "PLN"

type Scale "PLN" "PLN" = (,) Nat Nat 100 1

type Scale "PLN" "grosz"

type Scale "PLN" "grosz" = (,) Nat Nat 100 1

type Scale "PLN" "zloty"

type Scale "PLN" "zloty" = (,) Nat Nat 1 1

type Scale "PYG" "PYG"

type Scale "PYG" "PYG" = (,) Nat Nat 100 1

type Scale "PYG" "centimo"

type Scale "PYG" "centimo" = (,) Nat Nat 100 1

type Scale "PYG" "guarani"

type Scale "PYG" "guarani" = (,) Nat Nat 1 1

type Scale "QAR" "QAR"

type Scale "QAR" "QAR" = (,) Nat Nat 100 1

type Scale "QAR" "dirham"

type Scale "QAR" "dirham" = (,) Nat Nat 100 1

type Scale "QAR" "riyal"

type Scale "QAR" "riyal" = (,) Nat Nat 1 1

type Scale "RON" "RON"

type Scale "RON" "RON" = (,) Nat Nat 100 1

type Scale "RON" "ban"

type Scale "RON" "ban" = (,) Nat Nat 100 1

type Scale "RON" "leu"

type Scale "RON" "leu" = (,) Nat Nat 1 1

type Scale "RSD" "RSD"

type Scale "RSD" "RSD" = (,) Nat Nat 100 1

type Scale "RSD" "dinar"

type Scale "RSD" "dinar" = (,) Nat Nat 1 1

type Scale "RSD" "para"

type Scale "RSD" "para" = (,) Nat Nat 100 1

type Scale "RUB" "RUB"

type Scale "RUB" "RUB" = (,) Nat Nat 100 1

type Scale "RUB" "kopek"

type Scale "RUB" "kopek" = (,) Nat Nat 100 1

type Scale "RUB" "ruble"

type Scale "RUB" "ruble" = (,) Nat Nat 1 1

type Scale "RWF" "RWF"

type Scale "RWF" "RWF" = (,) Nat Nat 100 1

type Scale "RWF" "centime"

type Scale "RWF" "centime" = (,) Nat Nat 100 1

type Scale "RWF" "franc"

type Scale "RWF" "franc" = (,) Nat Nat 1 1

type Scale "SAR" "SAR"

type Scale "SAR" "SAR" = (,) Nat Nat 100 1

type Scale "SAR" "halala"

type Scale "SAR" "halala" = (,) Nat Nat 100 1

type Scale "SAR" "riyal"

type Scale "SAR" "riyal" = (,) Nat Nat 1 1

type Scale "SBD" "SBD"

type Scale "SBD" "SBD" = (,) Nat Nat 100 1

type Scale "SBD" "cent"

type Scale "SBD" "cent" = (,) Nat Nat 100 1

type Scale "SBD" "dollar"

type Scale "SBD" "dollar" = (,) Nat Nat 100 1

type Scale "SCR" "SCR"

type Scale "SCR" "SCR" = (,) Nat Nat 100 1

type Scale "SCR" "cent"

type Scale "SCR" "cent" = (,) Nat Nat 100 1

type Scale "SCR" "rupee"

type Scale "SCR" "rupee" = (,) Nat Nat 1 1

type Scale "SDG" "SDG"

type Scale "SDG" "SDG" = (,) Nat Nat 100 1

type Scale "SDG" "piastre"

type Scale "SDG" "piastre" = (,) Nat Nat 100 1

type Scale "SDG" "pound"

type Scale "SDG" "pound" = (,) Nat Nat 1 1

type Scale "SEK" "SEK"

type Scale "SEK" "SEK" = (,) Nat Nat 100 1

type Scale "SEK" "krona"

type Scale "SEK" "krona" = (,) Nat Nat 1 1

type Scale "SEK" "ore"

type Scale "SEK" "ore" = (,) Nat Nat 100 1

type Scale "SGD" "SGD"

type Scale "SGD" "SGD" = (,) Nat Nat 100 1

type Scale "SGD" "cent"

type Scale "SGD" "cent" = (,) Nat Nat 100 1

type Scale "SGD" "dollar"

type Scale "SGD" "dollar" = (,) Nat Nat 1 1

type Scale "SHP" "SHP"

type Scale "SHP" "SHP" = (,) Nat Nat 100 1

type Scale "SHP" "penny"

type Scale "SHP" "penny" = (,) Nat Nat 100 1

type Scale "SHP" "pound"

type Scale "SHP" "pound" = (,) Nat Nat 1 1

type Scale "SLL" "SLL"

type Scale "SLL" "SLL" = (,) Nat Nat 100 1

type Scale "SLL" "cent"

type Scale "SLL" "cent" = (,) Nat Nat 100 1

type Scale "SLL" "leone"

type Scale "SLL" "leone" = (,) Nat Nat 1 1

type Scale "SOS" "SOS"

type Scale "SOS" "SOS" = (,) Nat Nat 100 1

type Scale "SOS" "cent"

type Scale "SOS" "cent" = (,) Nat Nat 100 1

type Scale "SOS" "shilling"

type Scale "SOS" "shilling" = (,) Nat Nat 1 1

type Scale "SRD" "SRD"

type Scale "SRD" "SRD" = (,) Nat Nat 100 1

type Scale "SRD" "cent"

type Scale "SRD" "cent" = (,) Nat Nat 100 1

type Scale "SRD" "dollar"

type Scale "SRD" "dollar" = (,) Nat Nat 1 1

type Scale "SSP" "SSP"

type Scale "SSP" "SSP" = (,) Nat Nat 100 1

type Scale "SSP" "piastre"

type Scale "SSP" "piastre" = (,) Nat Nat 100 1

type Scale "SSP" "pound"

type Scale "SSP" "pound" = (,) Nat Nat 1 1

type Scale "STD" "STD"

type Scale "STD" "STD" = (,) Nat Nat 100 1

type Scale "STD" "centimo"

type Scale "STD" "centimo" = (,) Nat Nat 100 1

type Scale "STD" "dobra"

type Scale "STD" "dobra" = (,) Nat Nat 1 1

type Scale "SVC" "SVC"

type Scale "SVC" "SVC" = (,) Nat Nat 100 1

type Scale "SVC" "centavo"

type Scale "SVC" "centavo" = (,) Nat Nat 100 1

type Scale "SVC" "colon"

type Scale "SVC" "colon" = (,) Nat Nat 1 1

type Scale "SYP" "SYP"

type Scale "SYP" "SYP" = (,) Nat Nat 100 1

type Scale "SYP" "piastre"

type Scale "SYP" "piastre" = (,) Nat Nat 100 1

type Scale "SYP" "pound"

type Scale "SYP" "pound" = (,) Nat Nat 1 1

type Scale "SZL" "SZL"

type Scale "SZL" "SZL" = (,) Nat Nat 100 1

type Scale "SZL" "cent"

type Scale "SZL" "cent" = (,) Nat Nat 100 1

type Scale "SZL" "lilangeni"

type Scale "SZL" "lilangeni" = (,) Nat Nat 1 1

type Scale "THB" "THB"

type Scale "THB" "THB" = (,) Nat Nat 100 1

type Scale "THB" "baht"

type Scale "THB" "baht" = (,) Nat Nat 1 1

type Scale "THB" "satang"

type Scale "THB" "satang" = (,) Nat Nat 100 1

type Scale "TJS" "TJS"

type Scale "TJS" "TJS" = (,) Nat Nat 100 1

type Scale "TJS" "diram"

type Scale "TJS" "diram" = (,) Nat Nat 100 1

type Scale "TJS" "somoni"

type Scale "TJS" "somoni" = (,) Nat Nat 1 1

type Scale "TMT" "TMT"

type Scale "TMT" "TMT" = (,) Nat Nat 100 1

type Scale "TMT" "manat"

type Scale "TMT" "manat" = (,) Nat Nat 1 1

type Scale "TMT" "tennesi"

type Scale "TMT" "tennesi" = (,) Nat Nat 100 1

type Scale "TND" "TND"

type Scale "TND" "TND" = (,) Nat Nat 1000 1

type Scale "TND" "dinar"

type Scale "TND" "dinar" = (,) Nat Nat 1 1

type Scale "TND" "millime"

type Scale "TND" "millime" = (,) Nat Nat 1000 1

type Scale "TOP" "TOP"

type Scale "TOP" "TOP" = (,) Nat Nat 100 1

type Scale "TOP" "pa'anga"

type Scale "TOP" "pa'anga" = (,) Nat Nat 1 1

type Scale "TOP" "seniti"

type Scale "TOP" "seniti" = (,) Nat Nat 100 1

type Scale "TRY" "TRY"

type Scale "TRY" "TRY" = (,) Nat Nat 100 1

type Scale "TRY" "kurus"

type Scale "TRY" "kurus" = (,) Nat Nat 100 1

type Scale "TRY" "lira"

type Scale "TRY" "lira" = (,) Nat Nat 1 1

type Scale "TTD" "TTD"

type Scale "TTD" "TTD" = (,) Nat Nat 100 1

type Scale "TTD" "cent"

type Scale "TTD" "cent" = (,) Nat Nat 100 1

type Scale "TTD" "dollar"

type Scale "TTD" "dollar" = (,) Nat Nat 1 1

type Scale "TWD" "TWD"

type Scale "TWD" "TWD" = (,) Nat Nat 100 1

type Scale "TWD" "cent"

type Scale "TWD" "cent" = (,) Nat Nat 100 1

type Scale "TWD" "dollar"

type Scale "TWD" "dollar" = (,) Nat Nat 1 1

type Scale "TZS" "TZS"

type Scale "TZS" "TZS" = (,) Nat Nat 100 1

type Scale "TZS" "cent"

type Scale "TZS" "cent" = (,) Nat Nat 100 1

type Scale "TZS" "shilling"

type Scale "TZS" "shilling" = (,) Nat Nat 1 1

type Scale "UAH" "UAH"

type Scale "UAH" "UAH" = (,) Nat Nat 100 1

type Scale "UAH" "hryvnia"

type Scale "UAH" "hryvnia" = (,) Nat Nat 1 1

type Scale "UAH" "kopiyka"

type Scale "UAH" "kopiyka" = (,) Nat Nat 100 1

type Scale "UGX" "UGX"

type Scale "UGX" "UGX" = (,) Nat Nat 100 1

type Scale "UGX" "cent"

type Scale "UGX" "cent" = (,) Nat Nat 100 1

type Scale "UGX" "shilling"

type Scale "UGX" "shilling" = (,) Nat Nat 1 1

type Scale "USD" "USD"

type Scale "USD" "USD" = (,) Nat Nat 100 1

type Scale "USD" "cent"

type Scale "USD" "cent" = (,) Nat Nat 100 1

type Scale "USD" "dollar"

type Scale "USD" "dollar" = (,) Nat Nat 1 1

type Scale "USN" "USN"

type Scale "USN" "USN" = (,) Nat Nat 100 1

type Scale "UYI" "UYI"

type Scale "UYI" "UYI" = (,) Nat Nat 100 1

type Scale "UYU" "UYU"

type Scale "UYU" "UYU" = (,) Nat Nat 100 1

type Scale "UYU" "centesimo"

type Scale "UYU" "centesimo" = (,) Nat Nat 100 1

type Scale "UYU" "peso"

type Scale "UYU" "peso" = (,) Nat Nat 1 1

type Scale "UZS" "UZS"

type Scale "UZS" "UZS" = (,) Nat Nat 100 1

type Scale "UZS" "som"

type Scale "UZS" "som" = (,) Nat Nat 1 1

type Scale "UZS" "tiyin"

type Scale "UZS" "tiyin" = (,) Nat Nat 100 1

type Scale "VEF" "VEF"

type Scale "VEF" "VEF" = (,) Nat Nat 100 1

type Scale "VEF" "bolivar"

type Scale "VEF" "bolivar" = (,) Nat Nat 1 1

type Scale "VEF" "centimo"

type Scale "VEF" "centimo" = (,) Nat Nat 100 1

type Scale "VND" "VND"

type Scale "VND" "VND" = (,) Nat Nat 10 1

type Scale "VND" "dong"

type Scale "VND" "dong" = (,) Nat Nat 1 1

type Scale "VND" "hao"

type Scale "VND" "hao" = (,) Nat Nat 10 1

type Scale "VUV" "VUV"

type Scale "VUV" "VUV" = (,) Nat Nat 1 1

type Scale "VUV" "vatu"

type Scale "VUV" "vatu" = (,) Nat Nat 1 1

type Scale "WST" "WST"

type Scale "WST" "WST" = (,) Nat Nat 100 1

type Scale "WST" "sene"

type Scale "WST" "sene" = (,) Nat Nat 100 1

type Scale "WST" "tala"

type Scale "WST" "tala" = (,) Nat Nat 1 1

type Scale "XAF" "XAF"

type Scale "XAF" "XAF" = (,) Nat Nat 100 1

type Scale "XAF" "centime"

type Scale "XAF" "centime" = (,) Nat Nat 100 1

type Scale "XAF" "franc"

type Scale "XAF" "franc" = (,) Nat Nat 1 1

type Scale "XAG" "XAG"

type Scale "XAG" "XAG" = ErrScaleNonCanonical (Nat, Nat) "XAG"

type Scale "XAG" "grain"

type Scale "XAG" "grain" = (,) Nat Nat 480 1

type Scale "XAG" "gram"

type Scale "XAG" "gram" = (,) Nat Nat 31103477 1000000

type Scale "XAG" "kilogram"

type Scale "XAG" "kilogram" = (,) Nat Nat 31103477 1000000000

type Scale "XAG" "micrograin"

type Scale "XAG" "micrograin" = (,) Nat Nat 480000000 1

type Scale "XAG" "microgram"

type Scale "XAG" "microgram" = (,) Nat Nat 31103477 1

type Scale "XAG" "milligrain"

type Scale "XAG" "milligrain" = (,) Nat Nat 480000 1

type Scale "XAG" "milligram"

type Scale "XAG" "milligram" = (,) Nat Nat 31103477 1000

type Scale "XAG" "troy-ounce"

type Scale "XAG" "troy-ounce" = (,) Nat Nat 1 1

type Scale "XAU" "XAU"

type Scale "XAU" "XAU" = ErrScaleNonCanonical (Nat, Nat) "XAU"

type Scale "XAU" "grain"

type Scale "XAU" "grain" = (,) Nat Nat 480 1

type Scale "XAU" "gram"

type Scale "XAU" "gram" = (,) Nat Nat 31103477 1000000

type Scale "XAU" "kilogram"

type Scale "XAU" "kilogram" = (,) Nat Nat 31103477 1000000000

type Scale "XAU" "micrograin"

type Scale "XAU" "micrograin" = (,) Nat Nat 480000000 1

type Scale "XAU" "microgram"

type Scale "XAU" "microgram" = (,) Nat Nat 31103477 1

type Scale "XAU" "milligrain"

type Scale "XAU" "milligrain" = (,) Nat Nat 480000 1

type Scale "XAU" "milligram"

type Scale "XAU" "milligram" = (,) Nat Nat 31103477 1000

type Scale "XAU" "troy-ounce"

type Scale "XAU" "troy-ounce" = (,) Nat Nat 1 1

type Scale "XBT" "XBT"

type Scale "XBT" "XBT" = (,) Nat Nat 100000000 1

type Scale "XBT" "bitcoin"

type Scale "XBT" "bitcoin" = (,) Nat Nat 1 1

type Scale "XBT" "satoshi"

type Scale "XBT" "satoshi" = (,) Nat Nat 100000000 1

type Scale "XCD" "XCD"

type Scale "XCD" "XCD" = (,) Nat Nat 100 1

type Scale "XCD" "cent"

type Scale "XCD" "cent" = (,) Nat Nat 100 1

type Scale "XCD" "dollar"

type Scale "XCD" "dollar" = (,) Nat Nat 1 1

type Scale "XDR" "XDR"

type Scale "XDR" "XDR" = (,) Nat Nat 100 1

type Scale "XMR" "XMR"

type Scale "XMR" "XMR" = (,) Nat Nat 1000000000000 1

type Scale "XMR" "centinero"

type Scale "XMR" "centinero" = (,) Nat Nat 100 1

type Scale "XMR" "decinero"

type Scale "XMR" "decinero" = (,) Nat Nat 10 1

type Scale "XMR" "micronero"

type Scale "XMR" "micronero" = (,) Nat Nat 1000000 1

type Scale "XMR" "millinero"

type Scale "XMR" "millinero" = (,) Nat Nat 1000 1

type Scale "XMR" "monero"

type Scale "XMR" "monero" = (,) Nat Nat 1 1

type Scale "XMR" "nanonero"

type Scale "XMR" "nanonero" = (,) Nat Nat 1000000000 1

type Scale "XMR" "piconero"

type Scale "XMR" "piconero" = (,) Nat Nat 1000000000000 1

type Scale "XOF" "XOF"

type Scale "XOF" "XOF" = (,) Nat Nat 100 1

type Scale "XOF" "centime"

type Scale "XOF" "centime" = (,) Nat Nat 100 1

type Scale "XOF" "franc"

type Scale "XOF" "franc" = (,) Nat Nat 1 1

type Scale "XPD" "XPD"

type Scale "XPD" "XPD" = ErrScaleNonCanonical (Nat, Nat) "XPD"

type Scale "XPD" "grain"

type Scale "XPD" "grain" = (,) Nat Nat 480 1

type Scale "XPD" "gram"

type Scale "XPD" "gram" = (,) Nat Nat 31103477 1000000

type Scale "XPD" "kilogram"

type Scale "XPD" "kilogram" = (,) Nat Nat 31103477 1000000000

type Scale "XPD" "micrograin"

type Scale "XPD" "micrograin" = (,) Nat Nat 480000000 1

type Scale "XPD" "microgram"

type Scale "XPD" "microgram" = (,) Nat Nat 31103477 1

type Scale "XPD" "milligrain"

type Scale "XPD" "milligrain" = (,) Nat Nat 480000 1

type Scale "XPD" "milligram"

type Scale "XPD" "milligram" = (,) Nat Nat 31103477 1000

type Scale "XPD" "troy-ounce"

type Scale "XPD" "troy-ounce" = (,) Nat Nat 1 1

type Scale "XPF" "XPF"

type Scale "XPF" "XPF" = (,) Nat Nat 100 1

type Scale "XPF" "centime"

type Scale "XPF" "centime" = (,) Nat Nat 100 1

type Scale "XPF" "franc"

type Scale "XPF" "franc" = (,) Nat Nat 1 1

type Scale "XPT" "XPT"

type Scale "XPT" "XPT" = ErrScaleNonCanonical (Nat, Nat) "XPT"

type Scale "XPT" "grain"

type Scale "XPT" "grain" = (,) Nat Nat 480 1

type Scale "XPT" "gram"

type Scale "XPT" "gram" = (,) Nat Nat 31103477 1000000

type Scale "XPT" "kilogram"

type Scale "XPT" "kilogram" = (,) Nat Nat 31103477 1000000000

type Scale "XPT" "micrograin"

type Scale "XPT" "micrograin" = (,) Nat Nat 480000000 1

type Scale "XPT" "microgram"

type Scale "XPT" "microgram" = (,) Nat Nat 31103477 1

type Scale "XPT" "milligrain"

type Scale "XPT" "milligrain" = (,) Nat Nat 480000 1

type Scale "XPT" "milligram"

type Scale "XPT" "milligram" = (,) Nat Nat 31103477 1000

type Scale "XPT" "troy-ounce"

type Scale "XPT" "troy-ounce" = (,) Nat Nat 1 1

type Scale "XRP" "XRP"

type Scale "XRP" "XRP" = (,) Nat Nat 1000000 1

type Scale "XRP" "drop"

type Scale "XRP" "drop" = (,) Nat Nat 1000000 1

type Scale "XRP" "ripple"

type Scale "XRP" "ripple" = (,) Nat Nat 1 1

type Scale "XSU" "XSU"

type Scale "XSU" "XSU" = (,) Nat Nat 100 1

type Scale "XUA" "XUA"

type Scale "XUA" "XUA" = (,) Nat Nat 100 1

type Scale "YER" "YER"

type Scale "YER" "YER" = (,) Nat Nat 100 1

type Scale "YER" "fils"

type Scale "YER" "fils" = (,) Nat Nat 100 1

type Scale "YER" "rial"

type Scale "YER" "rial" = (,) Nat Nat 1 1

type Scale "ZAR" "ZAR"

type Scale "ZAR" "ZAR" = (,) Nat Nat 100 1

type Scale "ZAR" "cent"

type Scale "ZAR" "cent" = (,) Nat Nat 100 1

type Scale "ZAR" "rand"

type Scale "ZAR" "rand" = (,) Nat Nat 1 1

type Scale "ZMW" "ZMW"

type Scale "ZMW" "ZMW" = (,) Nat Nat 100 1

type Scale "ZMW" "kwacha"

type Scale "ZMW" "kwacha" = (,) Nat Nat 1 1

type Scale "ZMW" "ngwee"

type Scale "ZMW" "ngwee" = (,) Nat Nat 100 1

type Scale "ZWL" "ZWL"

type Scale "ZWL" "ZWL" = (,) Nat Nat 100 1

type Scale "ZWL" "cent"

type Scale "ZWL" "cent" = (,) Nat Nat 100 1

type Scale "ZWL" "dollar"

type Scale "ZWL" "dollar" = (,) Nat Nat 1 1

type GoodScale (scale :: (Nat, Nat)) = (CmpNat 0 (Fst scale) ~ LT, CmpNat 0 (Snd scale) ~ LT, KnownNat (Fst scale), KnownNat (Snd scale))

Constraints to a scale (like the one returned by Scale currency unit) expected to always be satisfied. In particular, the scale is always guaranteed to be a positive rational number (infinity and notANumber are forbidden by GoodScale).

type family ErrScaleNonCanonical (currency :: Symbol) :: k where ...

A friendly TypeError to use for a currency that doesn't have a canonical small unit.

Equations

ErrScaleNonCanonical c = TypeError ((Text c :<>: Text " is not a currency with a canonical smallest unit,") :$$: Text "be explicit about the currency unit you want to use.")

scale

Arguments

:: GoodScale scale

=> proxy scale

-> Rational

Term-level representation of a currrency scale.

For example, the Scale for "USD" in "cent"s is 100/1.

> scale (Proxy :: Proxy (Scale "USD" "cent"))
100 % 1

> scale (x :: Discrete "USD" "cent")
100 % 1

The returned Rational is statically guaranteed to be a positive number.

Currency exchange

data ExchangeRate (src :: Symbol) (dst :: Symbol)

Exchange rate for converting monetary values of currency src into monetary values of currency dst by multiplying for it.

For example, if in order to convert USD to GBP we have to multiply by 1.2345, then we can represent this situaion using:

exchangeRate (12345 % 10000) :: Maybe (ExchangeRate "USD" "GBP")

Instances

Category Symbol ExchangeRate

Composition of ExchangeRates multiplies exchange rates together:

exchangeRateToRational x * exchangeRateToRational y  ==  exchangeRateToRational (x . y)

Identity:

x  ==  x . id  ==  id . x

Associativity:

x . y . z  ==  x . (y . z)  ==  (x . y) . z

Conmutativity (provided the types allow for composition):

x . y  ==  y . x

Reciprocal:

1  ==  exchangeRateToRational (x . exchangeRateRecip x)

Methods

id :: cat a a

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

Eq (ExchangeRate src dst)

Methods

(==) :: ExchangeRate src dst -> ExchangeRate src dst -> Bool

(/=) :: ExchangeRate src dst -> ExchangeRate src dst -> Bool

Ord (ExchangeRate src dst)

Methods

compare :: ExchangeRate src dst -> ExchangeRate src dst -> Ordering

(<) :: ExchangeRate src dst -> ExchangeRate src dst -> Bool

(<=) :: ExchangeRate src dst -> ExchangeRate src dst -> Bool

(>) :: ExchangeRate src dst -> ExchangeRate src dst -> Bool

(>=) :: ExchangeRate src dst -> ExchangeRate src dst -> Bool

max :: ExchangeRate src dst -> ExchangeRate src dst -> ExchangeRate src dst

min :: ExchangeRate src dst -> ExchangeRate src dst -> ExchangeRate src dst

(KnownSymbol src, KnownSymbol dst) => Read (ExchangeRate src dst)

Methods

readsPrec :: Int -> ReadS (ExchangeRate src dst)

readList :: ReadS [ExchangeRate src dst]

readPrec :: ReadPrec (ExchangeRate src dst)

readListPrec :: ReadPrec [ExchangeRate src dst]

(KnownSymbol src, KnownSymbol dst) => Show (ExchangeRate src dst)

> show (exchangeRate (5 % 7) :: Maybe (ExchangeRate "USD" "JPY"))@
Just "ExchangeRate \"USD\" \"JPY\" 5%7"

Methods

showsPrec :: Int -> ExchangeRate src dst -> ShowS

show :: ExchangeRate src dst -> String

showList :: [ExchangeRate src dst] -> ShowS

Generic (ExchangeRate src dst)

Associated Types

type Rep (ExchangeRate src dst) :: * -> *

Methods

from :: ExchangeRate src dst -> Rep (ExchangeRate src dst) x

to :: Rep (ExchangeRate src dst) x -> ExchangeRate src dst

Hashable (ExchangeRate src dst)

Methods

hashWithSalt :: Int -> ExchangeRate src dst -> Int

hash :: ExchangeRate src dst -> Int

(KnownSymbol src, KnownSymbol dst) => ToJSON (ExchangeRate src dst)

Compatible with SomeExchangeRate

Example rendering an ExchangeRate constructed with exchangeRate (5 % 7) :: ExchangeRate "USD" "JPY"

["USD", "JPY", 5, 7]

Note: The JSON serialization changed in version 0.4 (the leading ExchangeRate string was dropped from the rendered Array).

Methods

toJSON :: ExchangeRate src dst -> Value

toEncoding :: ExchangeRate src dst -> Encoding

toJSONList :: [ExchangeRate src dst] -> Value

toEncodingList :: [ExchangeRate src dst] -> Encoding

(KnownSymbol src, KnownSymbol dst) => FromJSON (ExchangeRate src dst)

Compatible with SomeExchangeRate

Note: The JSON serialization changed in version 0.4. However, this instance is still able to cope with the previous format.

Methods

parseJSON :: Value -> Parser (ExchangeRate src dst)

parseJSONList :: Value -> Parser [ExchangeRate src dst]

(KnownSymbol src, KnownSymbol dst) => Binary (ExchangeRate src dst)

Compatible with SomeExchangeRate.

Methods

put :: ExchangeRate src dst -> Put

get :: Get (ExchangeRate src dst)

putList :: [ExchangeRate src dst] -> Put

(KnownSymbol src, KnownSymbol dst) => Serialize (ExchangeRate src dst)

Compatible with SomeExchangeRate.

Methods

put :: Putter (ExchangeRate src dst)

get :: Get (ExchangeRate src dst)

NFData (ExchangeRate src dst)

Methods

rnf :: ExchangeRate src dst -> ()

(KnownSymbol src, KnownSymbol dst) => Serialise (ExchangeRate src dst)

Compatible with SomeExchangeRate.

Methods

encode :: ExchangeRate src dst -> Encoding

decode :: Decoder s (ExchangeRate src dst)

encodeList :: [ExchangeRate src dst] -> Encoding

decodeList :: Decoder s [ExchangeRate src dst]

(KnownSymbol src, KnownSymbol dst) => Store (ExchangeRate src dst)

Compatible with SomeExchangeRate.

Methods

size :: Size (ExchangeRate src dst)

poke :: ExchangeRate src dst -> Poke ()

peek :: Peek (ExchangeRate src dst)

(KnownSymbol src, KnownSymbol dst) => FromXml (ExchangeRate src dst)

Compatible with SomeExchangeRate

Methods

fromXml :: Parser (ExchangeRate src dst)

(KnownSymbol src, KnownSymbol dst) => ToXml (ExchangeRate src dst)

Compatible with SomeExchangeRate

Example rendering an ExchangeRate constructed with exchangeRate (5 % 7) :: ExchangeRate "USD" "JPY"

<exchange-rate src="USD" dst="JPY" n="5" d="7"/>

Methods

toXml :: ExchangeRate src dst -> [Node]

type Rep (ExchangeRate src dst)

type Rep (ExchangeRate src dst) = D1 * (MetaData "ExchangeRate" "Money.Internal" "safe-money-0.6-FGfQdMihXU7686yGAy4rgF" True) (C1 * (MetaCons "ExchangeRate" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Rational)))

exchangeRate :: Rational -> Maybe (ExchangeRate src dst)

Safely construct an ExchangeRate from a *positive* Rational number.

exchange :: ExchangeRate src dst -> Dense src -> Dense dst

Apply the ExchangeRate to the given Dense src monetary value.

Identity law:

exchange (exchangeRateRecip x) . exchange x  ==  id

Use the Identity law for reasoning about going back and forth between src and dst in order to manage any leftovers that might not be representable as a Discrete monetary value of src.

exchangeRateRecip :: ExchangeRate a b -> ExchangeRate b a

Reciprocal ExchangeRate.

This function retuns the reciprocal or multiplicative inverse of the given ExchangeRate, leading to the following identity law:

exchangeRateRecip . exchangeRateRecip   ==  id

Note: If ExchangeRate had a Fractional instance, then exchangeRateRecip would be the implementation of recip.

exchangeRateFromDecimal

Arguments

:: Maybe Char

Thousands separator for the integer part, if any (i.e., the ',' in 1,234.56789).

-> Char

Decimal separator (i.e., the '.' in 1,234.56789)

-> Text

The raw string containing the decimal representation (e.g., "1,234.56789").

-> Maybe (ExchangeRate src dst)

Parses a decimal representation of an ExchangeRate.

exchangeRateToDecimal

Arguments

:: Approximation

Approximation to use if necesary in order to fit the Dense amount in as many decimal numbers as requested.

-> Maybe Char

Thousands separator for the integer part, if any (i.e., the ',' in 1,234.56789).

-> Char

Decimal separator (i.e., the '.' in 1,234.56789)

-> Word8

Number of decimal numbers to render, if any.

-> ExchangeRate src dst

The ExchangeRate to render.

-> Maybe Text

Returns Nothing if the given separators are not acceptable (i.e., they are digits, or they are equal).

Render a ExchangeRate as a decimal number in a potentially lossy manner.

> exchangeRateToDecimal Round True (Just ',') '.' 2
      =<< (exchangeRate (123456 % 100) :: Maybe (ExchangeRate "USD" "EUR"))
Just "1,234.56"

This function returns Nothing if it is not possible to reliably render the decimal string due to a bad choice of separators. That is, if the separators are digits or equal among themselves, this function returns Nothing.

exchangeRateToRational :: ExchangeRate src dst -> Rational

Obtain a Rational representation of the ExchangeRate.

This Rational is guaranteed to be a positive number.

Serializable representations

data SomeDense

A monomorphic representation of Dense that is easier to serialize and deserialize than Dense in case you don't know the type indexes involved.

If you are trying to construct a value of this type from some raw input, then you will need to use the mkSomeDense function.

In order to be able to effectively serialize a SomeDense value, you need to serialize the following three values (which are the eventual arguments to mkSomeDense):

• someDenseCurrency
• someDenseAmount

Instances

Eq SomeDense

Methods

(==) :: SomeDense -> SomeDense -> Bool

(/=) :: SomeDense -> SomeDense -> Bool

Ord SomeDense

WARNING This instance does not compare monetary amounts, it just helps you sort SomeDense values in case you need to put them in a Set or similar.

Methods

compare :: SomeDense -> SomeDense -> Ordering

(<) :: SomeDense -> SomeDense -> Bool

(<=) :: SomeDense -> SomeDense -> Bool

(>) :: SomeDense -> SomeDense -> Bool

(>=) :: SomeDense -> SomeDense -> Bool

max :: SomeDense -> SomeDense -> SomeDense

min :: SomeDense -> SomeDense -> SomeDense

Show SomeDense

Methods

showsPrec :: Int -> SomeDense -> ShowS

show :: SomeDense -> String

showList :: [SomeDense] -> ShowS

Generic SomeDense

Associated Types

type Rep SomeDense :: * -> *

Methods

from :: SomeDense -> Rep SomeDense x

to :: Rep SomeDense x -> SomeDense

Hashable SomeDense

Methods

hashWithSalt :: Int -> SomeDense -> Int

hash :: SomeDense -> Int

ToJSON SomeDense

Compatible with Dense

Note: The JSON serialization changed in version 0.4 (the leading Dense string was dropped from the rendered Array).

Methods

toJSON :: SomeDense -> Value

toEncoding :: SomeDense -> Encoding

toJSONList :: [SomeDense] -> Value

toEncodingList :: [SomeDense] -> Encoding

FromJSON SomeDense

Compatible with Dense.

Note: The JSON serialization changed in version 0.4. However, this instance is still able to cope with the previous format.

Methods

parseJSON :: Value -> Parser SomeDense

parseJSONList :: Value -> Parser [SomeDense]

Binary SomeDense

Compatible with Dense.

Methods

put :: SomeDense -> Put

get :: Get SomeDense

putList :: [SomeDense] -> Put

Serialize SomeDense

Compatible with Dense.

Methods

put :: Putter SomeDense

get :: Get SomeDense

NFData SomeDense

Methods

rnf :: SomeDense -> ()

Serialise SomeDense

Compatible with Dense.

Methods

encode :: SomeDense -> Encoding

decode :: Decoder s SomeDense

encodeList :: [SomeDense] -> Encoding

decodeList :: Decoder s [SomeDense]

Store SomeDense

Compatible with Dense.

Methods

size :: Size SomeDense

poke :: SomeDense -> Poke ()

peek :: Peek SomeDense

FromXml SomeDense

Compatible with Dense.

Methods

fromXml :: Parser SomeDense

ToXml SomeDense

Compatible with Dense

Methods

toXml :: SomeDense -> [Node]

type Rep SomeDense

type Rep SomeDense = D1 * (MetaData "SomeDense" "Money.Internal" "safe-money-0.6-FGfQdMihXU7686yGAy4rgF" False) (C1 * (MetaCons "SomeDense" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "_someDenseCurrency") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "_someDenseAmount") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Rational))))

toSomeDense :: KnownSymbol currency => Dense currency -> SomeDense

Convert a Dense to a SomeDense for ease of serialization.

mkSomeDense

Arguments

:: Text

Currency. (someDenseCurrency)

-> Rational

Scale. (someDenseAmount)

-> Maybe SomeDense

Build a SomeDense from raw values.

This function is intended for deserialization purposes. You need to convert this SomeDense value to a Dense value in order to do any arithmetic operation on the monetary value.

fromSomeDense

Arguments

:: KnownSymbol currency

=> SomeDense

-> Maybe (Dense currency)

Attempt to convert a SomeDense to a Dense, provided you know the target currency.

withSomeDense

Arguments

:: SomeDense

-> (forall currency. KnownSymbol currency => Dense currency -> r)

-> r

Convert a SomeDense to a Dense without knowing the target currency.

Notice that currency here can't leave its intended scope unless you can prove equality with some other type at the outer scope, but in that case you would be better off using fromSomeDense directly.

someDenseCurrency :: SomeDense -> Text

Currency name.

someDenseAmount :: SomeDense -> Rational

Currency unit amount.

data SomeDiscrete

A monomorphic representation of Discrete that is easier to serialize and deserialize than Discrete in case you don't know the type indexes involved.

If you are trying to construct a value of this type from some raw input, then you will need to use the mkSomeDiscrete function.

In order to be able to effectively serialize a SomeDiscrete value, you need to serialize the following four values (which are the eventual arguments to mkSomeDiscrete):

• someDiscreteCurrency
• someDiscreteScale
• someDiscreteAmount

Instances

Eq SomeDiscrete

Methods

(==) :: SomeDiscrete -> SomeDiscrete -> Bool

(/=) :: SomeDiscrete -> SomeDiscrete -> Bool

Ord SomeDiscrete

WARNING This instance does not compare monetary amounts, it just helps you sort SomeDiscrete values in case you need to put them in a Set or similar.

Methods

compare :: SomeDiscrete -> SomeDiscrete -> Ordering

(<) :: SomeDiscrete -> SomeDiscrete -> Bool

(<=) :: SomeDiscrete -> SomeDiscrete -> Bool

(>) :: SomeDiscrete -> SomeDiscrete -> Bool

(>=) :: SomeDiscrete -> SomeDiscrete -> Bool

max :: SomeDiscrete -> SomeDiscrete -> SomeDiscrete

min :: SomeDiscrete -> SomeDiscrete -> SomeDiscrete

Show SomeDiscrete

Methods

showsPrec :: Int -> SomeDiscrete -> ShowS

show :: SomeDiscrete -> String

showList :: [SomeDiscrete] -> ShowS

Generic SomeDiscrete

Associated Types

type Rep SomeDiscrete :: * -> *

Methods

from :: SomeDiscrete -> Rep SomeDiscrete x

to :: Rep SomeDiscrete x -> SomeDiscrete

Hashable SomeDiscrete

Methods

hashWithSalt :: Int -> SomeDiscrete -> Int

hash :: SomeDiscrete -> Int

ToJSON SomeDiscrete

Compatible with Discrete'

Note: The JSON serialization changed in version 0.4 (the leading Discrete string was dropped from the rendered Array).

Methods

toJSON :: SomeDiscrete -> Value

toEncoding :: SomeDiscrete -> Encoding

toJSONList :: [SomeDiscrete] -> Value

toEncodingList :: [SomeDiscrete] -> Encoding

FromJSON SomeDiscrete

Compatible with Discrete'

Note: The JSON serialization changed in version 0.4. However, this instance is still able to cope with the previous format.

Methods

parseJSON :: Value -> Parser SomeDiscrete

parseJSONList :: Value -> Parser [SomeDiscrete]

Binary SomeDiscrete

Compatible with Discrete.

Methods

put :: SomeDiscrete -> Put

get :: Get SomeDiscrete

putList :: [SomeDiscrete] -> Put

Serialize SomeDiscrete

Compatible with Discrete.

Methods

put :: Putter SomeDiscrete

get :: Get SomeDiscrete

NFData SomeDiscrete

Methods

rnf :: SomeDiscrete -> ()

Serialise SomeDiscrete

Compatible with Discrete.

Methods

encode :: SomeDiscrete -> Encoding

decode :: Decoder s SomeDiscrete

encodeList :: [SomeDiscrete] -> Encoding

decodeList :: Decoder s [SomeDiscrete]

Store SomeDiscrete

Compatible with Discrete'.

Methods

size :: Size SomeDiscrete

poke :: SomeDiscrete -> Poke ()

peek :: Peek SomeDiscrete

FromXml SomeDiscrete

Compatible with Discrete'

Methods

fromXml :: Parser SomeDiscrete

ToXml SomeDiscrete

Compatible with Discrete'

Methods

toXml :: SomeDiscrete -> [Node]

type Rep SomeDiscrete

type Rep SomeDiscrete = D1 * (MetaData "SomeDiscrete" "Money.Internal" "safe-money-0.6-FGfQdMihXU7686yGAy4rgF" False) (C1 * (MetaCons "SomeDiscrete" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "_someDiscreteCurrency") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * String)) ((:*:) * (S1 * (MetaSel (Just Symbol "_someDiscreteScale") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Rational)) (S1 * (MetaSel (Just Symbol "_someDiscreteAmount") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Integer)))))

toSomeDiscrete

Arguments

:: (KnownSymbol currency, GoodScale scale)

=> Discrete' currency scale

-> SomeDiscrete

Convert a Discrete to a SomeDiscrete for ease of serialization.

mkSomeDiscrete

Arguments

:: Text

Currency name. (someDiscreteCurrency)

-> Rational

Scale. Positive, non-zero. (someDiscreteScale)

-> Integer

Amount of unit. (someDiscreteAmount)

-> Maybe SomeDiscrete

Internal. Build a SomeDiscrete from raw values.

This function is intended for deserialization purposes. You need to convert this SomeDiscrete value to a Discrete vallue in order to do any arithmetic operation on the monetary value.

fromSomeDiscrete

Arguments

:: (KnownSymbol currency, GoodScale scale)

=> SomeDiscrete

-> Maybe (Discrete' currency scale)

Attempt to convert a SomeDiscrete to a Discrete, provided you know the target currency and unit.

withSomeDiscrete

Arguments

:: SomeDiscrete

-> (forall currency scale. (KnownSymbol currency, GoodScale scale) => Discrete' currency scale -> r)

-> r

Convert a SomeDiscrete to a Discrete without knowing the target currency and unit.

Notice that currency and unit here can't leave its intended scope unless you can prove equality with some other type at the outer scope, but in that case you would be better off using fromSomeDiscrete directly.

Notice that you may need to add an explicit type to the result of this function in order to keep the compiler happy.

someDiscreteCurrency :: SomeDiscrete -> Text

Currency name.

someDiscreteScale :: SomeDiscrete -> Rational

Positive, non-zero.

someDiscreteAmount :: SomeDiscrete -> Integer

Amount of currency unit.

data SomeExchangeRate

A monomorphic representation of ExchangeRate that is easier to serialize and deserialize than ExchangeRate in case you don't know the type indexes involved.

If you are trying to construct a value of this type from some raw input, then you will need to use the mkSomeExchangeRate function.

In order to be able to effectively serialize an SomeExchangeRate value, you need to serialize the following four values (which are the eventual arguments to mkSomeExchangeRate):

• someExchangeRateSrcCurrency
• someExchangeRateDstCurrency
• someExchangeRateRate

Instances

Eq SomeExchangeRate

Methods

(==) :: SomeExchangeRate -> SomeExchangeRate -> Bool

(/=) :: SomeExchangeRate -> SomeExchangeRate -> Bool

Ord SomeExchangeRate

WARNING This instance does not compare monetary amounts, it just helps you sort SomeExchangeRate values in case you need to put them in a Set or similar.

Methods

compare :: SomeExchangeRate -> SomeExchangeRate -> Ordering

(<) :: SomeExchangeRate -> SomeExchangeRate -> Bool

(<=) :: SomeExchangeRate -> SomeExchangeRate -> Bool

(>) :: SomeExchangeRate -> SomeExchangeRate -> Bool

(>=) :: SomeExchangeRate -> SomeExchangeRate -> Bool

max :: SomeExchangeRate -> SomeExchangeRate -> SomeExchangeRate

min :: SomeExchangeRate -> SomeExchangeRate -> SomeExchangeRate

Show SomeExchangeRate

Methods

showsPrec :: Int -> SomeExchangeRate -> ShowS

show :: SomeExchangeRate -> String

showList :: [SomeExchangeRate] -> ShowS

Generic SomeExchangeRate

Associated Types

type Rep SomeExchangeRate :: * -> *

Methods

from :: SomeExchangeRate -> Rep SomeExchangeRate x

to :: Rep SomeExchangeRate x -> SomeExchangeRate

Hashable SomeExchangeRate

Methods

hashWithSalt :: Int -> SomeExchangeRate -> Int

hash :: SomeExchangeRate -> Int

ToJSON SomeExchangeRate

Compatible with ExchangeRate

Note: The JSON serialization changed in version 0.4 (the leading ExchangeRate string was dropped from the rendered Array).

Methods

toJSON :: SomeExchangeRate -> Value

toEncoding :: SomeExchangeRate -> Encoding

toJSONList :: [SomeExchangeRate] -> Value

toEncodingList :: [SomeExchangeRate] -> Encoding

FromJSON SomeExchangeRate

Compatible with ExchangeRate

Note: The JSON serialization changed in version 0.4. However, this instance is still able to cope with the previous format.

Methods

parseJSON :: Value -> Parser SomeExchangeRate

parseJSONList :: Value -> Parser [SomeExchangeRate]

Binary SomeExchangeRate

Compatible with ExchangeRate.

Methods

put :: SomeExchangeRate -> Put

get :: Get SomeExchangeRate

putList :: [SomeExchangeRate] -> Put

Serialize SomeExchangeRate

Compatible with ExchangeRate.

Methods

put :: Putter SomeExchangeRate

get :: Get SomeExchangeRate

NFData SomeExchangeRate

Methods

rnf :: SomeExchangeRate -> ()

Serialise SomeExchangeRate

Compatible with ExchangeRate.

Methods

encode :: SomeExchangeRate -> Encoding

decode :: Decoder s SomeExchangeRate

encodeList :: [SomeExchangeRate] -> Encoding

decodeList :: Decoder s [SomeExchangeRate]

Store SomeExchangeRate

Compatible with ExchangeRate.

Methods

size :: Size SomeExchangeRate

poke :: SomeExchangeRate -> Poke ()

peek :: Peek SomeExchangeRate

FromXml SomeExchangeRate

Compatible with ExchangeRate

Methods

fromXml :: Parser SomeExchangeRate

ToXml SomeExchangeRate

Compatible with ExchangeRate

Methods

toXml :: SomeExchangeRate -> [Node]

type Rep SomeExchangeRate

type Rep SomeExchangeRate = D1 * (MetaData "SomeExchangeRate" "Money.Internal" "safe-money-0.6-FGfQdMihXU7686yGAy4rgF" False) (C1 * (MetaCons "SomeExchangeRate" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "_someExchangeRateSrcCurrency") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * String)) ((:*:) * (S1 * (MetaSel (Just Symbol "_someExchangeRateDstCurrency") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "_someExchangeRateRate") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Rational)))))

toSomeExchangeRate

Arguments

:: (KnownSymbol src, KnownSymbol dst)

=> ExchangeRate src dst

-> SomeExchangeRate

Convert a ExchangeRate to a SomeDiscrete for ease of serialization.

mkSomeExchangeRate

Arguments

:: Text

Source currency name. (someExchangeRateSrcCurrency)

-> Text

Destination currency name. (someExchangeRateDstCurrency)

-> Rational

Exchange rate . Positive, non-zero. (someExchangeRateRate)

-> Maybe SomeExchangeRate

Internal. Build a SomeExchangeRate from raw values.

This function is intended for deserialization purposes. You need to convert this SomeExchangeRate value to a ExchangeRate value in order to do any arithmetic operation with the exchange rate.

fromSomeExchangeRate

Arguments

:: (KnownSymbol src, KnownSymbol dst)

=> SomeExchangeRate

-> Maybe (ExchangeRate src dst)

Attempt to convert a SomeExchangeRate to a ExchangeRate, provided you know the target src and dst types.

withSomeExchangeRate

Arguments

:: SomeExchangeRate

-> (forall src dst. (KnownSymbol src, KnownSymbol dst) => ExchangeRate src dst -> r)

-> r

Convert a SomeExchangeRate to a ExchangeRate without knowing the target currency and unit.

Notice that src and dst here can't leave its intended scope unless you can prove equality with some other type at the outer scope, but in that case you would be better off using fromSomeExchangeRate directly.

someExchangeRateSrcCurrency :: SomeExchangeRate -> Text

Source currency name.

someExchangeRateDstCurrency :: SomeExchangeRate -> Text

Destination currency name.

someExchangeRateRate :: SomeExchangeRate -> Rational

Exchange rate. Positive, non-zero.

Misc

data Approximation

Method for approximating a fractional number to an integer number.

Constructors

Round

Approximate x to the nearest integer, or to the nearest even integer if x is equidistant between two integers.

Floor

Approximate x to the nearest integer less than or equal to x.

Ceiling

Approximate x to the nearest integer greater than or equal to x.

Truncate

Approximate x to the nearest integer betwen 0 and x, inclusive.

Instances

Eq Approximation

Methods

(==) :: Approximation -> Approximation -> Bool

(/=) :: Approximation -> Approximation -> Bool

Ord Approximation

Methods

compare :: Approximation -> Approximation -> Ordering

(<) :: Approximation -> Approximation -> Bool

(<=) :: Approximation -> Approximation -> Bool

(>) :: Approximation -> Approximation -> Bool

(>=) :: Approximation -> Approximation -> Bool

max :: Approximation -> Approximation -> Approximation

min :: Approximation -> Approximation -> Approximation

Read Approximation

Methods

readsPrec :: Int -> ReadS Approximation

readList :: ReadS [Approximation]

readPrec :: ReadPrec Approximation

readListPrec :: ReadPrec [Approximation]

Show Approximation

Methods

showsPrec :: Int -> Approximation -> ShowS

show :: Approximation -> String

showList :: [Approximation] -> ShowS

Generic Approximation

Associated Types

type Rep Approximation :: * -> *

Methods

from :: Approximation -> Rep Approximation x

to :: Rep Approximation x -> Approximation

Hashable Approximation

Methods

hashWithSalt :: Int -> Approximation -> Int

hash :: Approximation -> Int

NFData Approximation

Methods

rnf :: Approximation -> ()

type Rep Approximation

type Rep Approximation = D1 * (MetaData "Approximation" "Money.Internal" "safe-money-0.6-FGfQdMihXU7686yGAy4rgF" False) ((:+:) * ((:+:) * (C1 * (MetaCons "Round" PrefixI False) (U1 *)) (C1 * (MetaCons "Floor" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "Ceiling" PrefixI False) (U1 *)) (C1 * (MetaCons "Truncate" PrefixI False) (U1 *))))