Composing Contracts Part 4: Sample Usage

Composing contracts: an adventure in financial engineering
http://research.microsoft.com/en-us/um/people/simonpj/papers/financial-contracts/contracts-icfp.htm

open System

open ContractDataTypes

open Contracts

let t1 = Date(DateTime.Today.AddSeconds(10.0))

// zero-coupon bond

let c1 = zcb t1 10.0 USD

let ret = eval c1

ret.Subscribe(printf "%A")

Console.ReadLine ()

Composing Contracts Part 3: Sample Implementation

module Contracts

open System

open System.Linq

open ContractDataTypes

let date s = Date (DateTime.Parse s)

let one c = One c

let scale k c = Scale(k, c)

let konst x = rx { return x }

let (==*) l r = rx { let! x = l

                     let! y = r

                     return x = y }

let obsTime = rx { let! x = Observable.Interval(TimeSpan.FromSeconds(1.0))

                   return Date(DateTime.Today.AddSeconds (float x)) }

let at t = obsTime ==* (konst t)

let cWhen t c = When (t, c)

// zero-coupon bond

let zcb t x k = cWhen (at t) (scale (konst x) (one k))

let rec eval c = match c with

                 | When (t, c) -> rx { let! x = t

                                       if x then

                                            return! (eval c)  }

                 | Scale (k, c) -> rx { let! x = k

                                        let! y = eval c

                                        return x * y }

                 | One c -> match c with

                            | GBP -> rx { return Money (1.0, GBP) }

                            | USD -> rx { return Money (0.675310643, GBP) }

Composing Contracts Part 2: Signatures

module Contracts

open System

open ContractDataTypes

val date: String -> Date

val one : Currency -> Contract

val scale : IObservable<double> -> Contract -> Contract

val konst : 'a -> IObservable<'a>

val (==*) : IObservable<'a> -> IObservable<'a> -> IObservable<bool> when 'a : equality

val obsTime : IObservable<Date>

val at: Date -> IObservable<bool>

val cWhen: IObservable<bool> -> Contract -> Contract

// zero-coupon bond

val zcb : Date -> Double -> Currency -> Contract

val eval: Contract -> IObservable<Money>

Composing Contracts Part 1: Data Types

module ContractDataTypes

open System

open System.Linq

type Date = Date of DateTime

type Days = Days of TimeSpan

type Currency = GBP | USD

type Money = Money of float * Currency

    with static member (*) (k, Money (v, c)) = Money (k * v, c)

type Contract = | One of Currency

                | Scale of (IObservable<double> * Contract)

                | When of (IObservable<bool> * Contract)

type RxBuilder() =

    member this.Bind(m:IObservable<'a>, f:'a -> IObservable<'b>) =

        Observable.SelectMany(m, new Func<'a, IObservable<'b>> (f))

    member this.Return x = Observable.Return x

    member this.ReturnFrom x = x

    member this.Zero() = Observable.Empty()

let rx = RxBuilder()

Monad State Transformer

This is an attempt to write a State Monad Transformer.
I haven't been able to make it generic and according to
Brian McNamara "this will never be possible in any .NET language"


 http://cs.hubfs.net/forums/thread/13974.aspx

type StateT<'a, 'b, 'state> = StateT of ('state -> Parser<'a * 'state, 'b>)

type StateTBuilder (p:ParserMonad) =

    // a -> m a

    member this.Return a = StateT (fun s -> p.Return(a, s))

    //  m a -> (a -> m b) -> m b

    member this.Bind (m, f) =  StateT (fun s -> p {  let! (v, s') = let (StateT f) = m in f s

                                                     let (StateT f') = f v

                                                     return! f' s' })

let statefulParser = StateTBuilder(parser)

let getState = StateT (fun s -> parser.Return(s, s))

let setState s = StateT (fun _ -> parser.Return((), s))

let lift c = StateT (fun s -> parser.Bind (c, (fun x -> parser.Return (x, s))))

let Execute m s = let (StateT f) = m in

                  parser { let! (x,_) = f s

                           return x  }