So this is my first attempt at implementing a computational expression in F#. I’m not going to go into definitions or the likes as to what computational expressions are as there are far better posts out there on this subject than I could probably write, at this time. I’ll list some in a “further reading” section at the end of the post.<\/p>\n
What I’m going to present here is a builder which really just creates a list of names – nothing particularly clever – but it gives a basic idea on getting started with computational expressions (I hope).<\/p>\n
So first off we need to create a builder type, mine’s called CurveBuilder<\/p>\n
\r\ntype Items = Items of string list\r\n\r\ntype CurveBuilder() =\r\n member this.Yield (()) = Items []\r\n\r\n [<CustomOperation ("create", MaintainsVariableSpace = true)>]\r\n member this.Create (Items sources, name: string) = \r\n Items [ yield! sources\r\n yield name ]\r\n<\/pre>\nAs this is just a simple demo, the only thing I’m doing is creating a list of strings which you would be correct in thinking that I could do easier using a collection class, but I’m really just interested in seeing the builder and it’s interactions without too much clutter, so go with me on this one…<\/p>\n
Before we discuss the builder code, let’s take a look at how we’d use a builder in our application<\/p>\n
\r\nlet builder = CurveBuilder()\r\n\r\nlet curves = \r\n builder {\r\n create "risky_curve1.gbp"\r\n create "risky_curve2.usd"\r\n }\r\n<\/pre>\nIn this code we first create an instance of a CurveBuilder, then when we use the builder to create a list of the curves. The Yield method is first called on the CurveBuilder, returning an empty Items value. Subsequent calls to the create<\/em> method then call the Create<\/em> method of the CurveBuilder and, as can be seen, create a new Items value containing the previous Items plus our new curve name.<\/p>\nSimple enough but surely there’s more to this than meets the eye<\/strong><\/p>\nThe example above is a minimal implementation, of course, of a builder. You’ll notice that we have an attribute on one method (the Create method) and not on the Yield method.<\/p>\n
So the attribute CustomOperation<\/a> is used on a member of a builder to create new “query operators”. Basically it extends the builder functionality with new operators named whatever you want to name them.<\/p>\nOn the other hand the Yield method is a “standard” builder method. There are several other methods which F# knows about implicitly within a builder class, including Return, Zero, Bind, For, YieldFrom, ReturnFrom, Delay, Combine, Run and more, see Computation Expressions (F#)
\n<\/a> for a full list of “built-in workflows”. With these we can obviously produce something more complex than the example presented in this post – which is in essence a glorified “list” builder with snazzy syntax.<\/p>\nDiscriminated Union gotcha<\/strong><\/p>\nOne thing I got caught out with from the above code is that I wanted to simply list the curves I’d created but couldn’t figure out how to “deconstruct” the discriminated union<\/p>\n
\r\ntype Items = Items of string list\r\n<\/pre>\nto a simple string list – at this point I claim ignorance as I’m not using F# as much as I’d like so am still fairly inexperienced with it.<\/p>\n
My aim was to produce something like this<\/p>\n
\r\nfor curve in curves do\r\n printfn "Curve: %s" curve\r\n<\/pre>\nbut this failed with the error The type ‘Items’ is not a type whose values can be enumerated with this syntax, i.e. is not compatible with either seq<_>, IEnumerable<_> or IEnumerable and does not have a GetEnumerator method<\/em><\/p>\nI need to in essence disconnect the Items from the string list, to achieve this I found the excellent post Discriminated Unions<\/a>.<\/p>\nThe solution is as follows<\/p>\n
\r\nlet (Items items) = curves\r\n\r\nfor curve in items do\r\n printfn "Curve: %s" curve\r\n<\/pre>\nNote: the let (Items items) = curves<\/em><\/p>\nFurther Reading<\/strong>
\nImplementing a builder: Zero and Yield<\/a>
\nImplementing a builder: Combine<\/a>
\nImplementing a builder: Delay and Run<\/a>
\nImplementing a builder: Overloading<\/a>
\nImplementing a builder: Adding laziness<\/a>
\nImplementing a builder: The rest of the standard methods<\/a><\/p>\n