• Home

  • Documents

  • Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles ->...
29
3/12/2009 1 What is F#? Microsoft Multi-paradigm Language CLR – All the .NET platform benefits First class language in to Visual Studio 2010 What about F# makes it functional or concurrent? Immutable Constructs Higher Order Functions Partial Application Ability to do lazy evaluation Asynchronous Workflows

Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

  • Upload
    others

  • View
    3

  • Download
    0

Embed Size (px)

Citation preview

Page 1: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

1

What is F#?

Microsoft Multi-paradigm Language

CLR – All the .NET platform benefits

First class language in to Visual Studio 2010

What about F# makes it functional or concurrent?

Immutable Constructs

Higher Order Functions

Partial Application

Ability to do lazy evaluation

Asynchronous Workflows

Page 2: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

2

Real World Application!

Auto Insurance Rating Engine

Page 3: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

3

Page 4: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

4

List of Policies

Policy

Calculation

Policy

Calculation

Driver Factor

Coverage Coverage Coverage

Vehicle

Driver Driver

Vehicle

Driver Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Calculation

Why can’t it be faster?

Page 5: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

5

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let rec Rate (policies: System.Collections.Generic.List<Policy>) =

let policies = List.of_seq policies

let rec exec = function

|[] -> ()

|p::tail -> async{

calcCoverages(p, GetCurrentRates(p), GetCoverages(p))

} |> Async.Spawn

exec tail

exec policies

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 6: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

6

let Rate (policies: System.Collections.Generic.List<Policy>) =

let policies = List.of_seq policies

let rec exec = function

|[] -> ()

|p::tail -> async{

calcCoverages(p, GetCurrentRates(p), GetCoverages(p))

} |> Async.Spawn

exec tail

exec policies

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let rec Rate (policies: System.Collections.Generic.List<Policy>) =

let policies = List.of_seq policies

let rec exec = function

|[] -> ()

|p::tail -> async{

calcCoverages(p, GetCurrentRates(p), GetCoverages(p))

} |> Async.Spawn

exec tail

exec policies

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 7: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

7

let rec Rate (policies: System.Collections.Generic.List<Policy>) =

let policies = List.of_seq policies

let rec exec = function

|[] -> ()

|p::tail -> async{

calcCoverages(p, GetCurrentRates(p), GetCoverages(p))

} |> Async.Spawn

exec tail

exec policies

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let rec Rate (policies: System.Collections.Generic.List<Policy>) =

let policies = List.of_seq policies

let rec exec = function

|[] -> ()

|p::tail -> async{

calcCoverages(p, GetCurrentRates(p), GetCoverages(p))

} |> Async.Spawn

exec tail

exec policies

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 8: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

8

let rec calcCoverages (policy:Policy) rates coverages = function

| [] -> ()

| c::tail -> updatePolicy(policy (Async.Run(GetRates policy rates c)))

calcCoverages policy rates tail

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let rec calcCoverages (policy:Policy) rates coverages = function

| [] -> ()

| c::tail -> updatePolicy(policy (Async.Run(GetRates policy rates c)))

calcCoverages policy rates tail

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 9: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

9

let GetRates (policy:Policy) rates coverage =

async{

let! results = Async.Parallel[

for v in Policy.vehicles ->

async{return (Result policy v coverage rates).Force()}

]

return (coverage, Seq.reduce(+) results)}

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let GetRates (policy:Policy) rates coverage =

async{

let! results = Async.Parallel[

for v in Policy.vehicles ->

async{return (Result policy v coverage rates).Force()}

]

return (coverage, Seq.reduce(+) results)}

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 10: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

10

let GetRates (policy:Policy) rates coverage =

async{

let! results = Async.Parallel[

for v in Policy.vehicles ->

async{return (Result policy v coverage rates).Force()}

]

return (coverage, Seq.reduce(+) results)}

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let GetRates (policy:Policy) rates coverage =

async{

let! results = Async.Parallel[

for v in Policy.vehicles ->

async{return (Result policy v coverage rates).Force()}

]

return (coverage, Seq.reduce(+) results)}

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 11: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

11

let GetRates (policy:Policy) rates coverage =

async{

let! results = Async.Parallel[

for v in Policy.vehicles ->

async{return (Result policy v coverage rates).Force()}

]

return (coverage, Seq.reduce(+) results)}

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let GetRates (policy:Policy) rates coverage =

async{

let! results = Async.Parallel[

for v in Policy.vehicles ->

async{return (Result policy v coverage rates).Force()}

]

return (coverage, Seq.reduce(+) results)}

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 12: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

12

let Result (p:Policy)(v:Vehicle)(c:AutoCoverage)(r:CurrentRates) =

lazy(

let QueryRate(rq:RateQuery) =

rq.Coverage <- c.ToInt()

r.GetRate(rq) ...

BasicPolicyFactor()

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let Result (p:Policy)(v:Vehicle)(c:AutoCoverage)(r:CurrentRates) =

lazy(

let QueryRate(rq:RateQuery) =

rq.Coverage <- c.ToInt()

r.GetRate(rq) ...

BasicPolicyFactor()

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 13: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

13

let Result (p:Policy)(v:Vehicle)(c:AutoCoverage)(r:CurrentRates) =

lazy(

let QueryRate(rq:RateQuery) =

rq.Coverage <- c.ToInt()

r.GetRate(rq) ...

BasicPolicyFactor()

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let Result (p:Policy)(v:Vehicle)(c:AutoCoverage)(r:CurrentRates) =

lazy(

let QueryRate(rq:RateQuery) =

rq.Coverage <- c.ToInt()

r.GetRate(rq) ...

BasicPolicyFactor()

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 14: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

14

let Result (p:Policy)(v:Vehicle)(c:AutoCoverage)(r:CurrentRates) =

lazy(

let QueryRate(rq:RateQuery) =

rq.Coverage <- c.ToInt()

r.GetRate(rq) ...

BasicPolicyFactor()

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let Result (p:Policy)(v:Vehicle)(c:AutoCoverage)(r:CurrentRates) =

lazy(

let QueryRate(rq:RateQuery) =

rq.Coverage <- c.ToInt()

r.GetRate(rq) ...

BasicPolicyFactor()

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 15: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

15

let BasicPolicyFactor() =

lazy(

Seq.map force [AverageDriverFactor();

MultiPolicyCombinationDiscount();

CompanyCarDiscount();]

|> Seq.reduce (*)

)

(Lazy<decimal>)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let BasicPolicyFactor() =

lazy(

Seq.map force [AverageDriverFactor();

MultiPolicyCombinationDiscount();

CompanyCarDiscount();]

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 16: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

16

let BasicPolicyFactor() =

lazy(

Seq.map force [AverageDriverFactor();

MultiPolicyCombinationDiscount();

CompanyCarDiscount();]

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let AverageDriverFactor() =

lazy(

let mutable accum = (decimal)0

for d in p.Drivers do

accum <- accum + (DriverFactor d).Force()

accum / (decimal)p.Drivers.Count)

(unit -> Lazy<decimal>)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 17: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

17

let AverageDriverFactor() =

lazy(

let mutable accum = (decimal)0

for d in p.Drivers do

accum <- accum + (DriverFactor d).Force()

accum / (decimal)p.Drivers.Count)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let AverageDriverFactor() =

lazy(

let mutable accum = (decimal)0

for d in p.Drivers do

accum <- accum + (DriverFactor d).Force()

accum / (decimal)p.Drivers.Count)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 18: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

18

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 19: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

19

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let InsuranceScoreFactor (d:Driver) =

let rq = new RateQuery(RateTableType.CreditScoreFactor)

rq.Age <- Common.CalculateDriverAge(d.BirthDate, p)

let rec scoreCalc() =

match d.InsuranceScoreAttribute.ToString() with

| "CBRN" when score < 2 -> -2

| "CBRS" when score < 2 -> -3

| "CBRW" when score < 2 -> -4

| "CBRV" when score < 2 -> -5

| "CBRX" when score < 2 -> -6

| _ -> d.InsuranceScore

rq.CreditScore <- scoreCalc()

QueryRate rq

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 20: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

20

let InsuranceScoreFactor (d:Driver) =

let rq = new RateQuery(RateTableType.CreditScoreFactor)

rq.Age <- Common.CalculateDriverAge(d.BirthDate, p)

let rec scoreCalc() =

match d.InsuranceScoreAttribute.ToString() with

| "CBRN" when score < 2 -> -2

| "CBRS" when score < 2 -> -3

| "CBRW" when score < 2 -> -4

| "CBRV" when score < 2 -> -5

| "CBRX" when score < 2 -> -6

| _ -> d.InsuranceScore

rq.CreditScore <- scoreCalc()

QueryRate rq

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let InsuranceScoreFactor (d:Driver) =

let rq = new RateQuery(RateTableType.CreditScoreFactor)

rq.Age <- Common.CalculateDriverAge(d.BirthDate, p)

let rec scoreCalc() =

match d.InsuranceScoreAttribute.ToString() with

| "CBRN" when score < 2 -> -2

| "CBRS" when score < 2 -> -3

| "CBRW" when score < 2 -> -4

| "CBRV" when score < 2 -> -5

| "CBRX" when score < 2 -> -6

| _ -> d.InsuranceScore

rq.CreditScore <- scoreCalc()

QueryRate rq

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 21: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

21

let InsuranceScoreFactor (d:Driver) =

let rq = new RateQuery(RateTableType.CreditScoreFactor)

rq.Age <- Common.CalculateDriverAge(d.BirthDate, p)

let rec scoreCalc() =

match d.InsuranceScoreAttribute.ToString() with

| "CBRN" when score < 2 -> -2

| "CBRS" when score < 2 -> -3

| "CBRW" when score < 2 -> -4

| "CBRV" when score < 2 -> -5

| "CBRX" when score < 2 -> -6

| _ -> d.InsuranceScore

rq.CreditScore <- scoreCalc()

QueryRate rq

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let InsuranceScoreFactor (d:Driver) =

let rq = new RateQuery(RateTableType.CreditScoreFactor)

rq.Age <- Common.CalculateDriverAge(d.BirthDate, p)

let rec scoreCalc() =

match d.InsuranceScoreAttribute.ToString() with

| "CBRN" when score < 2 -> -2

| "CBRS" when score < 2 -> -3

| "CBRW" when score < 2 -> -4

| "CBRV" when score < 2 -> -5

| "CBRX" when score < 2 -> -6

| _ -> d.InsuranceScore

rq.CreditScore <- scoreCalc()

QueryRate rq

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 22: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

22

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 23: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

23

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

let force (x:Lazy<x>) = x.Force()

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

decimal list

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 24: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

24

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let DriverFactor d =

lazy(

[BaseRate d;

DriverClassFactor d;

InsuranceScoreFactor d;

GoodStudentFactor d;

GrangeLifeFactor d;

AwayAtSchoolFactor d]

|> Seq.map force

|> Seq.reduce (*)

)

decimal

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 25: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

25

let AverageDriverFactor() =

lazy(

let mutable accum = (decimal)0

for d in p.Drivers do

accum <- accum + (DriverFactor d).Force()

accum / (decimal)p.Drivers.Count

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let AverageDriverFactor() =

lazy(

let mutable accum = (decimal)0

for d in p.Drivers do

accum <- accum + (DriverFactor d).Force()

accum / (decimal)p.Drivers.Count

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 26: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

26

let BasicPolicyFactor() =

lazy(

Seq.map force [AverageDriverFactor();

MultiPolicyCombinationDiscount();

CompanyCarDiscount();]

|> Seq.reduce (*)

)

(unit -> Lazy<decimal>)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let Result (p:Policy)(v:Vehicle)(c:AutoCoverage)(r:CurrentRates) =

lazy(

let QueryRate(rq:RateQuery) =

rq.Coverage <- c.ToInt()

r.GetRate(rq) ...

BasicPolicyFactor()

)

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 27: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

27

let GetRates (policy:Policy) rates coverage =

async{

let! results = Async.Parallel[

for v in Policy.vehicles ->

async{return (Result policy v coverage rates).Force()}

]

return (coverage, Seq.reduce(+) results)}

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

let CalcCoverages (policy:Policy) rates coverages = function

| [] -> ()

| c::tail -> updatePolicy(policy, (Async.Run(GetRates policy rates c)))

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 28: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

28

let rec Rate (policies: System.Collections.Generic.List<Policy>) =

let policies = List.of_seq policies

let rec exec = function

|[] -> ()

|p::tail -> async{

calcCoverages(p, GetCurrentRates(p), GetCoverages(p))

} |> Async.Spawn

exec tail

exec policies

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

(d1 + d2) / 2

Parallel

Parallel

Spawned Thread

Process List of Policies

Policy Policy

Coverage Coverage Coverage

Vehicle Vehicle

Basic Policy Factor

Avg Driver Factor

Driver

Driver Factor

Driver Factor

Driver

Company Car Factor

Multi-policy Factor

ZipcodeFactor

Policy

Coverage Coverage

Page 29: Real World F# · async{let! results = Async.Parallel[for v in Policy.vehicles -> async{return(Result policy v coverage rates).Force()}] return (coverage, Seq.reduce(+) results)} (d1

3/12/2009

29

1 5 10 20 40 50

C# 3 10 15 38 78 95

F# 1 4 7 15 20 35

#light

let RealWorld F# = Concurrent applications

Amanda Laucher

[email protected]

pandamonial.com

Twitter: pandamonial

mailto:[email protected]

Sync vs. Async programming, Tasks, C# 5 async and await, WinRT async operations George Georgiev Telerik Corporation Technical Trainer itgeorge.net

Sync vs. Async programming, Tasks, C# 5 async and await, WinRT async operations George Georgiev Telerik Corporation Technical Trainer itgeorge.net

Documents
Falling in love with async await in love with async await.pdf · Falling in love with async await Atishay Jain Agenda About me The async-await paradigm A

Falling in love with async await in love with async await.pdf · Falling in love with async await Atishay Jain Agenda About me The async-await paradigm A

Documents
Think Async

Think Async

Documents
Mysqlnd Async Ipc2008

Mysqlnd Async Ipc2008

Technology
Async, await

Async, await

Technology
Async with C# 5sddconf.com/brands/sdd/library/C_Sharp_Async_Await.pdf · async and await async method must return void or a Task async method should include an await await

Async with C# 5sddconf.com/brands/sdd/library/C_Sharp_Async_Await.pdf · async and await async method must return void or a Task async method should include an await await

Documents
Async discussion 9_29_15

Async discussion 9_29_15

Engineering
Async/Sync and Sync/Async Bridge Scenarios - SAP CPI/HCI

Async/Sync and Sync/Async Bridge Scenarios - SAP CPI/HCI

Documents
Asynchronous and parallel F# 3 Asynchronous and parallel C# 4sestoft/bachelor/fsharp-async-parallel-2014.pdf · [ for i in 0..40 -> async { return slowfib(i) } ] Async.Parallel

Asynchronous and parallel F# 3 Asynchronous and parallel C# 4sestoft/bachelor/fsharp-async-parallel-2014.pdf · [ for i in 0..40 -> async { return slowfib(i) } ] Async.Parallel

Documents
ASYNC ASYNC/MULTIDROP SYNC SYNC & ASYNC · ASYNC DB-25, DB-9, DB-15 ASYNC/MULTIDROP DB-25, DB-9 SYNC SYNC & ASYNC Low Speed Model 1110A Page 216 ASYNC RS-232 Model 1140A Page 216

ASYNC ASYNC/MULTIDROP SYNC SYNC & ASYNC · ASYNC DB-25, DB-9, DB-15 ASYNC/MULTIDROP DB-25, DB-9 SYNC SYNC & ASYNC Low Speed Model 1110A Page 216 ASYNC RS-232 Model 1140A Page 216

Documents
Async Programming WITH ASYNC TASK

Async Programming WITH ASYNC TASK

Documents
Dental Coverage - mybenefitchoices.com · Dental Coverage Here is your new dental coverage, which includes your enrollment form. Make sure you return the ... Guardian is a leading

Dental Coverage - mybenefitchoices.com · Dental Coverage Here is your new dental coverage, which includes your enrollment form. Make sure you return the ... Guardian is a leading

Documents
Click async Task LoadSettingsAsync() { await IO.Network.DownloadAsync(path); } async void Button1_Click(){ await LoadSettingsAsync(); UpdateView();

Click async Task LoadSettingsAsync() { await IO.Network.DownloadAsync(path); } async void Button1_Click(){ await LoadSettingsAsync(); UpdateView();

Documents
Sane Async Patterns

Sane Async Patterns

Technology
Xavier async callback_fault

Xavier async callback_fault

Software
Async ASP.NET Applications

Async ASP.NET Applications

Software
{ async patterns }

{ async patterns }

Documents
Async/Sync and Sync/Async Bridge Scenarios · Async/Sync and Sync/Async Bridge Scenarios Configuring Async/Sync Bridge and Sync/Async Bridge without BPM

Async/Sync and Sync/Async Bridge Scenarios · Async/Sync and Sync/Async Bridge Scenarios Configuring Async/Sync Bridge and Sync/Async Bridge without BPM

Documents
What is async? How does async fix hangs? How do I use async? Ben’s 5 top tips

What is async? How does async fix hangs? How do I use async? Ben’s 5 top tips

Documents
ASync FIFO

ASync FIFO

Documents
Async - cs.cornell.edu · Bind Deferred.bind (return 42) (fun n -> return (n+1))• first argument is a deferred that is determined with value 42 • second argument is a callback

Async - cs.cornell.edu · Bind Deferred.bind (return 42) (fun n -> return (n+1))• first argument is a deferred that is determined with value 42 • second argument is a callback

Documents
Async Javascript

Async Javascript

Technology
Training – Going Async

Training – Going Async

Software
Syncing Async

Syncing Async

Internet
Async DeepDive basics

Async DeepDive basics

Software
Async Best Practices

Async Best Practices

Technology
74F786arbitter async

74F786arbitter async

Documents
Async vs Futures

Async vs Futures

Documents
Его Высочество Async

Его Высочество Async

Documents
Async Frontiers

Async Frontiers

Technology