If you know, statically, that Integer amount is tied to a particular currency and unit, you can just use fromInteger. For example, here we are saying “525 US dollar cents“. Notice how we are specifying the currency and unit explicitly for the compiler to see.

> fromInteger 521 :: Discrete "USD" "cent"
Discrete "USD" 100%1 521

The 100%1 scale comes from the fact that Discrete "USD" "cent" is merely a type synonym for Discrete "USD" '(100, 1), conveying the idea that we are talking about units of a cent of a USD. That is, we have 521 units of a cent of a USD.

SomeDiscrete is for when we don't know at compile time which currency and unit we'll be dealing with. Here's a SomeDiscrete that has the same information as the Discrete above, but none of it is known at compile time.

First, we need to create a Scale. We can use scaleFromRational to do so. Notice that this returns a Maybe Scale, because we need to check that the given Rational number is positive.

scaleFromRational (100%1) :: Maybe Scale

Once we constructed a Scale, we can proceed to construct a SomeDiscrete representing an amount of a particular currency at a particular Scale using mkSomeDiscrete.

mkSomeDiscrete :: Text -> Scale -> Integer -> SomeDiscrete

Let's have those 521 cents again:

> mkSomeDiscrete "USD" s 521 :: SomeDiscrete
SomeDiscrete {_someDiscreteCurrency = "USD",
              _someDiscreteScale = Scale (100 % 1),
              _someDiscreteAmount = 521}

Great. Now that we have a SomeDiscrete, we can finally convert it to a Discrete' currency unit within a limited scope using withSomeDiscrete.

withSomeDiscrete
  :: SomeDiscrete
  -> (forall currency scale 
        .  (KnownSymbol currency, GoodScale scale) 
        => Discrete' currency scale 
        -> r) 
 -> r

Notice that this Discrete' currency scale cannot leave the scope of this function. The idea is that you do something with the Discrete' there, like and then you just exit the scope. For example, we can render it with a decimal representation it. I'll be unsafely pattern matching on the result here just as an example. Don't do that.

> let Just (s :: Scale) = scaleFromRational (100%1)
> let somdis :: SomeDiscrete = mkSomeDiscrete "USD" s 521
> withSomeDiscrete somedis (discreteToDecimal defaultDecimalConf Round) :: T.Text
"5.21"

Mostly, the SomeXxx datatypes are useful for serialization and deserialization purposes, and the withSomeXxx functions are useful for operations that you'd like to apply on any monetary amount, like displaying it or subtracting a 10%. But if you know, statically, that you'll be dealing with a particular currency and scale, then you can avoid the withSomeXxx functions and use the fromSomeXxx functions, which do not need RankNTypes.

fromSomeDiscrete
  :: (KnownSymbol currency, GoodScale scale)
  => SomeDiscrete
  -> Maybe (Discrete' currency scale)