This Domain-Specific Language (DSL) lets you perform operations among different currencies, by transparently doing all internal conversions. The conversion map is injected implicitly by the client code.
As a first step you need to add the resolver and dependency to your build file:
resolvers += "lambdista at bintray" at "https://dl.bintray.com/lambdista/maven"
libraryDependencies += "com.lambdista" %% "money" % "0.7.0"
You can find all the released versions here.
Builds are available for Scala 2.13.x, 2.12.x and 2.11.x.
Here's a simple usage example:
import money._
object Usage {
def main(args: Array[String]): Unit = {
val conversion: Conversion = Map(
(EUR, USD) -> 1.13,
(EUR, GBP) -> 0.71,
(USD, EUR) -> 0.88,
(USD, GBP) -> 0.63,
(GBP, EUR) -> 1.40,
(GBP, USD) -> 1.59
)
implicit val converter = Converter(conversion)
val sumAndConversion1 = 100.001 (USD) + 200 (EUR) to GBP
println(s"sumAndConversion1: $sumAndConversion1")
val sumAndConversion2: Money = 100 (USD) + 210.4 (EUR) to EUR
println(s"sumAndConversion2: $sumAndConversion2")
val sum = 100.001 (USD) + 200 (EUR)
val simpleConversion = sum to GBP
println(s"simpleConversion: $simpleConversion")
val sumWithSimpleNumber = 100 (USD) + 23.560
println(s"sumWithSimpleNumber: $sumWithSimpleNumber")
val multiplicationWithSimpleNumber = 100 (USD) * 23
println(s"multiplicationWithSimpleNumber: $multiplicationWithSimpleNumber")
val usd = Currency("USD")
val multiplication = 100 (usd) * 23
println(s"multiplication: $multiplication")
val divisionWithSimpleNumber = 100 (USD) / 23
println(s"divisionWithSimpleNumber: $divisionWithSimpleNumber")
val comparison = 100 (USD) > 99 (EUR)
println(s"100 USD > 99 EUR? $comparison")
}
}
As you can see the client code just needs a simple import and an implicit value of type Converter
in order to use the DSL. The operations shown in the previous code are only a few among the available ones.
Have a look at the Money
class for a complete coverage.
To run the previous example launch:
$ sbt run
To play with Scala's REPL launch:
$ sbt console
This will automatically fire the Scala's REPL and run the following commands for you:
import money._
val conversion: Conversion = Map(
(EUR, USD) -> 1.13,
(EUR, GBP) -> 0.71,
(USD, EUR) -> 0.88,
(USD, GBP) -> 0.63,
(GBP, EUR) -> 1.40,
(GBP, USD) -> 1.59
)
implicit val converter = Converter(conversion)
This way you can start playing with the DSL expressions (e.g.: 100(USD) + 90(EUR)
) without worrying about imports
and the conversion map. Of course if you need to use your own conversion you can redefine it.
When using the following import:
import money._
you get the default implicit for Numeric[Money]
whose implementation is as follows:
implicit def numericMoney(implicit converter: Converter) = new NumericMoney(DEFAULT_CURRENCY)
It uses DEFAULT_CURRENCY
, which is USD
. That's necessary for the fromInt
method of Numeric
:
def fromInt(x: Int): Money
That is, in order to create a Money
object you need a Currency
.
If you intend to use a different currency you can define your own implicit Numeric[Money]
, e.g.:
implicit def numericMoney(implicit converter: Converter) = new NumericMoney(EUR)
For bugs, questions and discussions please use the Github Issues.
Copyright 2014 Alessandro Lacava.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.