{"id":2184,"date":"2022-10-10T20:56:10","date_gmt":"2022-10-10T20:56:10","guid":{"rendered":"http:\/\/putridparrot.com\/blog\/?p=2184"},"modified":"2022-10-11T08:27:48","modified_gmt":"2022-10-11T08:27:48","slug":"computational-expressions-the-standard-methods","status":"publish","type":"post","link":"https:\/\/putridparrot.com\/blog\/computational-expressions-the-standard-methods\/","title":{"rendered":"Computational Expressions, the “standard” methods"},"content":{"rendered":"

Note: This post was written a while back but sat in draft. I’ve published this now, but I’m not sure it’s relevant to the latest versions etc. so please bear this in mind.<\/em><\/p>\n

So in a previous post I looked at my first attempt at creating a computational expression in F#. By anyone’s level this was basic. So I figured it was time to look at all the available “standard” methods available for a computational expression. By “standard” I means those which are implciitly recognized by F# as opposed to creating custom methods.<\/p>\n

See Computation Expressions (F#)<\/a> for more info.<\/p>\n

There are plenty of posts on this subject from Microsoft or F# for fun or profit, so why am I writing yet another post – basically just to give my perspective and to help me remember this stuff.<\/p>\n

Let’s start with the basics, we have a type SampleBuilder defined as<\/p>\n

\r\ntype SampleBuilder() =\r\n   \/\/ our code will be filled is as required \r\n   \/\/ but an example might have just the following\r\n   member this.Bind(m, f) = f m\r\n<\/pre>\n
We shall use the builder thus<\/p>\n
\r\nlet builder = SampleBuilder()\r\n\r\nbuilder {\r\n   \/\/ expressions, such as \r\n   let x = 100\r\n}\r\n<\/pre>\n
and now to the various builder methods…<\/p>\n
Bind<\/strong><\/p>\n
\r\nlet! x = 100\r\n\r\n\/\/ translates to\r\n\r\nbuilder.Bind(100, (fun x -> expression))\r\n<\/pre>\n
So as can be seen, in essence the order of the arguments is reversed. So if we were to simply duplicate the way let<\/em> binding works but in a computational expression we’d write something like<\/p>\n
\r\nmember this.Bind(m, f) = \r\n   f m\r\n<\/pre>\n
Return and ReturnFrom<\/strong><\/p>\n
At the time of writing this, I’m a little confused as to the difference between Return and ReturnFrom. Computation expressions and wrapper types<\/a> states that the Return returns a wrapped type whilst ReturnFrom returns an unwrapped type. However it is seems it’s possible to pretty much return whatever I like as shown below<\/p>\n
\r\nmember this.Return(x) = x\r\n\r\nmember this.ReturnFrom(x) = x\r\n<\/pre>\n
Return is called when we have a return in the computation expression, i.e.<\/p>\n
\r\nbuilder {\r\n   return 100\r\n} |> printfn "%A"\r\n<\/pre>\n
and ReturnFrom is used when return! exists, i.e.<\/p>\n
\r\nbuilder {\r\n   return! 100\r\n} |> printfn "%A"\r\n<\/pre>\n
One slightly odd thing if you’re used to C# or the likes is that we can have multiple return and\/or return! in a computational expression as per<\/p>\n
\r\nbuilder {\r\n   return 100\r\n   return! 100\r\n} |> printfn "%A"\r\n<\/pre>\n
As per multiple yield statements, we need a Combine method implemented in our builder to combine the return values. A return does not mean the rest of the computational expression is not executed, it means that the return values are combined to produce a value at the end of the workflow. So for example<\/p>\n
\r\nbuilder {\r\n   printfn "First"\r\n   return 100\r\n   printfn "Second"\r\n   return 100\r\n} |> printfn "%A"<\/pre>\n
Assuming our Return method and Combine are as simple as the following<\/p>\n
\r\nmember this.Return(x) = \r\n   printfn "Return"\r\n   x\r\n\r\nmember this.Combine(a, b) = a + b\r\n<\/pre>\n
Then our output will look like the following<\/p>\n
\r\nFirst\r\nReturn\r\nSecond\r\nReturn\r\n200\r\n<\/pre>\n
In other words, the first printfn (actually the Delay builder method is called for each printfn) is called then the Return method, then the second printfn then the second Return, then the Combine is called. In this case Combine simply adds the return values together to produce the output of the workflow.<\/p>\n
Combine<\/strong><\/p>\n
The combine method combines multiple values – so for example if you had something like the following<\/p>\n
\r\nbuilder {\r\n   yield 100\r\n   yield 200\r\n} |> printfn "%A"\r\n<\/pre>\n
without a combine method you’ll get the following compiler error This control construct may only be used if the computation expression builder defines a ‘Combine’ method<\/em>. Simple enough to see the problem here. So we cannot yield more than once unless we implement a combine method. Here’s an example which implements the combine by creating a list and combining elements into a new list<\/p>\n
\r\nmember this.Combine(a, b) = a @ b\r\n<\/pre>\n
If we now compile this code we’ll get another error, “This control construct may only be used if the computation expression builder defines a ‘Delay’ method”. So we need to implement a Delay method. See the example listed for Delay below…<\/p>\n
Delay<\/strong><\/p>\n
The Delay method allows the builder to delay the evaluation of a computational expression until it’s required. For example if we yield multiple times within a computational expression the idea is to combine the yields until we’re ready to invoke something. <\/p>\n
The example above creates a list of the yields and then in the Delay we might want to do something with those combined yields. In this example below we’ll simply use the following code<\/p>\n
\r\nmember this.Delay(f) = f()\r\n<\/pre>\n
which essentially just invokes the function passed to the delay.<\/p>\n
Run<\/strong><\/p>\n
Whilst the Delay method is used to delay evaluation, the Run method is mean’t to use the delayed expression, i.e. it might be to run something or the likes. An example which simply turns the list created by the combine into an array instead<\/p>\n
\r\nmember this.Run(f) = Array.ofList f\r\n<\/pre>\n
this is obviously a rather simplistic example, had our builder been creating the data for a web service call, for example, possibly run would make the call for us.<\/p>\n
For<\/strong><\/p>\n
I again must point anybody reading this section to the excellent post Implementing a builder: The rest of the standard methods<\/a> where an implementation of the For method is describe, for simplicity I’ll recreate it here<\/p>\n
\r\nmember this.For(sequence:seq<_>, body) =\r\n   this.Using(sequence.GetEnumerator(),fun enum -> \r\n      this.While(enum.MoveNext, \r\n         this.Delay(fun () -> body enum.Current)))\r\n<\/pre>\n
The Using, While and Delay methods are described elsewhere in this post.<\/p>\n
Here’s some sample code using the For method from our computational expression block<\/p>\n
\r\nbuilder {        \r\n   for i = 1 to 10 do\r\n      printfn "%d" i\r\n} \r\n<\/pre>\n
TryFinally<\/strong><\/p>\n
An implementation of the TryFinally method is fairly straightforward<\/p>\n
\r\nmember this.TryFinally(body, compensation) =\r\n   try this.ReturnFrom(body())\r\n   finally compensation() \r\n<\/pre>\n
and in usage within a computational expression block, we have<\/p>\n
\r\nbuilder {        \r\n   try\r\n      let x = 1 \/ 0\r\n      printfn "should not make it to here"\r\n   finally\r\n      printfn "exception"\r\n} \r\n<\/pre>\n
In the above code, when we step into the try block we will actually enter the TryFinally method and obviously this then takes over executing the body of the code and then executing the finally block.<\/p>\n
TryWith<\/strong><\/p>\n
Very much like the TryFinally block, we have the following implementation<\/p>\n
\r\nmember this.TryWith(body, handler) =\r\n   try this.ReturnFrom(body())\r\n   with e -> handler e\r\n<\/pre>\n
and an example of the computational expression block might be<\/p>\n
\r\nbuilder {        \r\n   try\r\n      let x = 1 \/ 0\r\n      printfn "should not make it to here"\r\n   with\r\n   | :? DivideByZeroException -> printfn "divide by zero"\r\n} <\/pre>\n
Using<\/strong><\/p>\n
As the name suggests, this is used for IDisposable types. Here’s a sample of it’s implementation<\/p>\n
\r\nmember thisTryFinally(body, compensation) =\r\n   try __.ReturnFrom(body())\r\n   finally compensation() \r\n\r\nmember this.Using(disposable:#System.IDisposable, body) =\r\n   let body' = fun () -> body disposable\r\n   this.TryFinally(body', fun () -> \r\n      match disposable with \r\n      | null -> () \r\n      | disp -> disp.Dispose())\r\n<\/pre>\n
The Using method relates to the use!<\/em> keyword and hence we might have code such as<\/p>\n
\r\nbuilder {        \r\n   use! x = new MemoryStream()\r\n   printfn "do something with the memory stream"\r\n} \r\n<\/pre>\n
So at the point use!<\/em> is invoked our Using method takes over. We i<\/p>\n
While<\/strong><\/p>\n
The example of a while loop in a computational expression was lifted from “Implementing a builder: The rest of the standard methods”<\/a> and I highly recommend anyone visiting this post goes and reads the computational expression series on F# for fun and profit.<\/p>\n
So our example code is as follows<\/p>\n
\r\nlet mutable i = 0\r\nlet test() = i < 5\r\nlet inc() = i <- i + 1\r\n\r\nlet builder = SampleBuilder()\r\n\r\nbuilder {        \r\n   while test() do\r\n      printfn "%i" i\r\n      inc()         \r\n} |> ignore\r\n<\/pre>\n
It’s important to note that the three let statements at the top of the source must be global or you’ll get an error along the lines of “The mutable variable ‘i’ is used in an invalid way. Mutable variables cannot be captured by closures. Consider eliminating this use of mutation or using a heap-allocated mutable reference cell via ‘ref’ and ‘!’.”<\/p>\n
So our builder code should look something like the following<\/p>\n
\r\nmember this.Bind(m, f) = f m\r\n\r\nmember this.Return(x) = x\r\n\r\nmember this.Zero() = this.Return ()\r\n\r\nmember this.Delay(f) = f\r\n\r\nmember this.Run(f) = f()\r\n\r\nmember this.While(guard, body) =\r\n   if not (guard()) \r\n   then \r\n      this.Zero() \r\n   else\r\n      this.Bind( body(), fun () -> \r\n         this.While(guard, body))  \r\n<\/pre>\n
So as can be seen, in the While method we are passed the guard and the body of the while loop and as expected we need to invoke these bits of code to evaluate them. When the guard completes we invoke the Zero method which in this case simply called the Return method. If the loop has not completed we simply keep looping.<\/p>\n
Yield and YieldFrom<\/strong><\/p>\n
We can use yield or yield! from a computational expression, but to do so we need to implement the Yield and YieldFrom methods (respectively) on the builder, otherwise we’ll be greeted with the “This control construct may only be used if the computation expression builder defines a ‘Yield’ method”, here’s an example of the yield being used from a computational expression block<\/p>\n
\r\nbuilder {\r\n   yield 100\r\n} |> printfn "%A"\r\n\r\n\/\/ or\r\n\r\nbuilder {\r\n   yield! 100\r\n} |> printfn "%A"\r\n<\/pre>\n
An example of the Yield and YieldFrom methods in the builder might look like the following<\/p>\n
\r\nmember this.Yield(x) = Some x\r\n\r\nmember this.YieldFrom(x) = x\r\n<\/pre>\n
Zero<\/strong><\/p>\n
You may have noticed, if you’ve written your own builder type that something like the following<\/p>\n
\r\nbuilder {\r\n}\r\n\r\n\/\/ or\r\n\r\nbuilder {\r\n} |> ignore\r\n<\/pre>\n
doesn’t compile, this is because a computational expression must<\/strong> have something within the curly braces. So if instead we write the following<\/p>\n
\r\nbuilder {\r\n   printfn "Hello"\r\n}\r\n<\/pre>\n
We’re get an altogether different error at compile time stating This control construct may only be used if the computational expression builder defines a ‘Zero’ method<\/em>. Basically a computational expression must return something, either explicitly or implicitly. In this case Zero is used for any implicit return, so we could resolve this error using <\/p>\n
\r\nmember this.Zero() = ()\r\n<\/pre>\n
or ofcourse we might implicitly return the same thing we would with an explicit return such as<\/p>\n
\r\nmember this.Return(x) = x\r\n\r\nmember this.Zero() = this.Return ()\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Note: This post was written a while back but sat in draft. I’ve published this now, but I’m not sure it’s relevant to the latest versions etc. so please bear this in mind. So in a previous post I looked at my first attempt at creating a computational expression in F#. By anyone’s level this […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[6],"tags":[],"class_list":["post-2184","post","type-post","status-publish","format-standard","hentry","category-f"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/2184","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/comments?post=2184"}],"version-history":[{"count":5,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/2184\/revisions"}],"predecessor-version":[{"id":9570,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/2184\/revisions\/9570"}],"wp:attachment":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/media?parent=2184"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/categories?post=2184"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/tags?post=2184"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}