4 people like it.

Multi-currency report

Multi-currency report (generated as HTML) based on example given at the start of chapter one of Kent Beck's Test-Driven Development by Example book.

Multi-currency domain

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 

type Money = private { Amount:decimal; Currency:Currency } 
   with   
   static member ( * ) (lhs:Money,rhs:decimal) = 
      { lhs with Amount=lhs.Amount * rhs }
   static member ( + ) (lhs:Money,rhs:Money) =
      if lhs.Currency <> rhs.Currency then invalidOp "Currency mismatch"
      { lhs with Amount=lhs.Amount + rhs.Amount}
   override money.ToString() = sprintf "%M%s" money.Amount money.Currency
and  Currency = string

type RateTable = { To:Currency; From:Map<Currency,decimal> }

let exchangeRate (rates:RateTable) cy =   
   if rates.To = cy then 1.0M else rates.From.[cy]

let convertCurrency (rates:RateTable) money =
   let rate = exchangeRate rates money.Currency
   { Amount=money.Amount / rate; Currency=rates.To }

Multi-currency report model

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 

type Report = { Rows:Row list; Total:Money }
and  Row = { Position:Position; Total:Money }
and  Position = { Instrument:string; Shares:int; Price:Money }

let generateReport rates positions =
   let rows =
      [for position in positions ->        
         let total = position.Price * decimal position.Shares
         { Position=position; Total=total } ]
   let total =
      rows
      |> Seq.map (fun row -> convertCurrency rates row.Total)   
      |> Seq.reduce (+)
   { Rows=rows; Total=total }

Multi-currency report view

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 

let toHtml (report:Report) =
   html [
      head [ title %"Multi-currency report" ]      
      body [
         table <|
            ("border"%="1") ::
            ("style"%="border-collapse:collapse;") ::
            ("cellpadding"%="8") ::
            thead [
               tr [th %"Instrument"; th %"Shares"; th %"Price"; th %"Total"] 
            ] ::
            tbody [
               for row in report.Rows ->
                  let p = row.Position
                  tr [td %p.Instrument; td %p.Shares; td %p.Price; td %row.Total]
            ] :: 
            [ tfoot [
               tr [td ("colspan"%="3"::"align"%="right"::[strong %"Total"])
                   td %report.Total]
            ]]
         ]
      ]

Example

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 

let USD amount = { Amount=amount; Currency="USD" }
let CHF amount = { Amount=amount; Currency="CHF" }

let positions =
   [{Instrument="IBM";      Shares=1000; Price=USD( 25M)}
    {Instrument="Novartis"; Shares= 400; Price=CHF(150M)}]

let inUSD = { To="USD"; From=Map.ofList ["CHF",1.5M] }

let positionsInUSD = generateReport inUSD positions

positionsInUSD |> toHtml |> Html.toString
type Money =
  private {Amount: decimal;
           Currency: Currency;}
  override ToString : unit -> string
  static member ( + ) : lhs:Money * rhs:Money -> Money
  static member ( * ) : lhs:Money * rhs:decimal -> Money

Full name: Script.Money
Money.Amount: decimal
Multiple items
val decimal : value:'T -> decimal (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.decimal

--------------------
type decimal = System.Decimal

Full name: Microsoft.FSharp.Core.decimal

--------------------
type decimal<'Measure> = decimal

Full name: Microsoft.FSharp.Core.decimal<_>
Multiple items
Money.Currency: Currency

--------------------
type Currency = string

Full name: Script.Currency
val lhs : Money
val rhs : decimal
val rhs : Money
Money.Currency: Currency
val invalidOp : message:string -> 'T

Full name: Microsoft.FSharp.Core.Operators.invalidOp
val money : Money
override Money.ToString : unit -> string

Full name: Script.Money.ToString
val sprintf : format:Printf.StringFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.sprintf
type Currency = string

Full name: Script.Currency
Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string
type RateTable =
  {To: Currency;
   From: Map<Currency,decimal>;}

Full name: Script.RateTable
RateTable.To: Currency
RateTable.From: Map<Currency,decimal>
Multiple items
module Map

from Microsoft.FSharp.Collections

--------------------
type Map<'Key,'Value (requires comparison)> =
  interface IEnumerable
  interface IComparable
  interface IEnumerable<KeyValuePair<'Key,'Value>>
  interface ICollection<KeyValuePair<'Key,'Value>>
  interface IDictionary<'Key,'Value>
  new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
  member Add : key:'Key * value:'Value -> Map<'Key,'Value>
  member ContainsKey : key:'Key -> bool
  override Equals : obj -> bool
  member Remove : key:'Key -> Map<'Key,'Value>
  ...

Full name: Microsoft.FSharp.Collections.Map<_,_>

--------------------
new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
val exchangeRate : rates:RateTable -> cy:Currency -> decimal

Full name: Script.exchangeRate
val rates : RateTable
val cy : Currency
val convertCurrency : rates:RateTable -> money:Money -> Money

Full name: Script.convertCurrency
val rate : decimal
type Report =
  {Rows: Row list;
   Total: Money;}

Full name: Script.Report
Report.Rows: Row list
type Row =
  {Position: Position;
   Total: Money;}

Full name: Script.Row
type 'T list = List<'T>

Full name: Microsoft.FSharp.Collections.list<_>
Report.Total: Money
Multiple items
Row.Position: Position

--------------------
type Position =
  {Instrument: string;
   Shares: int;
   Price: Money;}

Full name: Script.Position
Row.Total: Money
type Position =
  {Instrument: string;
   Shares: int;
   Price: Money;}

Full name: Script.Position
Position.Instrument: string
Position.Shares: int
Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>
Position.Price: Money
val generateReport : rates:RateTable -> positions:seq<Position> -> Report

Full name: Script.generateReport
val positions : seq<Position>
val rows : Row list
val position : Position
val total : Money
module Seq

from Microsoft.FSharp.Collections
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map
val row : Row
val reduce : reduction:('T -> 'T -> 'T) -> source:seq<'T> -> 'T

Full name: Microsoft.FSharp.Collections.Seq.reduce
val toHtml : report:Report -> Html

Full name: Script.toHtml
val report : Report
val html : (Html list -> Html)

Full name: Script.html
val head : (Html list -> Html)

Full name: Script.head
val title : (Html list -> Html)

Full name: Script.title
val body : (Html list -> Html)

Full name: Script.body
val table : (Html list -> Html)

Full name: Script.table
val thead : (Html list -> Html)

Full name: Script.thead
val tr : (Html list -> Html)

Full name: Script.tr
val th : (Html list -> Html)

Full name: Script.th
val tbody : (Html list -> Html)

Full name: Script.tbody
val p : Position
Row.Position: Position
val td : (Html list -> Html)

Full name: Script.td
val tfoot : (Html list -> Html)

Full name: Script.tfoot
val strong : (Html list -> Html)

Full name: Script.strong
val USD : amount:decimal -> Money

Full name: Script.USD
val amount : decimal
val CHF : amount:decimal -> Money

Full name: Script.CHF
val positions : Position list

Full name: Script.positions
val inUSD : RateTable

Full name: Script.inUSD
val ofList : elements:('Key * 'T) list -> Map<'Key,'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Map.ofList
val positionsInUSD : Report

Full name: Script.positionsInUSD
type Html =
  | Elem of string * Html list
  | Attr of string * string
  | Text of string
  override ToString : unit -> string
  static member toString : elem:Html -> string

Full name: Script.Html
static member Html.toString : elem:Html -> string

More information

Link:http://fssnip.net/r5
Posted:8 years ago
Author:Phillip Trelford
Tags: html , dsl , money

This web site is created using F# and Suave web server. It is hosted on Azure and the source code is on GitHub. Contributions are welcome!

The first version of fssnip.net has been created by @tomaspetricek back in 2010. This web site is a new, open-source and contribution-friendly version.