Jekyll2020-02-16T10:48:48+00:00http://www.garethrepton.com/feed.xmlGareth Reptons development blogC#, F#, OO, Functional, TDD, Sql and a bunch of other stuff. My views are my own.The end of the using ‘block’ in C# 8?2019-11-10T00:00:00+00:002019-11-10T00:00:00+00:00http://www.garethrepton.com/The%20end%20of%20the%20using%20block%20in%20CSharp<h2 id="intro">Intro</h2>
<p>C# 8 unfortunately seems to be branching away from the standard .Net Framework and its not (fully?) compatible with the full .Net Framework, instead you have to use DotNetCore to get the benefits of it.</p>
<p>That being said one of my favourite new features is the automatic using block scoping. Anything that removes some of the verbosity of the nested curly braces is good as far as I’m concerned.</p>
<h2 id="whats-changed">Whats changed?</h2>
<p>Its actually fairly simple, lets take a disposable class called “Test” as an example:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">public</span> <span class="k">class</span> <span class="nc">Test</span> <span class="p">:</span> <span class="n">IDisposable</span>
<span class="p">{</span>
<span class="k">private</span> <span class="kt">string</span> <span class="n">name</span><span class="p">;</span>
<span class="k">public</span> <span class="kt">string</span> <span class="n">Name</span> <span class="p">=></span> <span class="n">name</span><span class="p">;</span>
<span class="k">public</span> <span class="nf">Test</span><span class="p">(</span><span class="kt">string</span> <span class="n">name</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">this</span><span class="p">.</span><span class="n">name</span> <span class="p">=</span> <span class="n">name</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">Dispose</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"ending </span><span class="p">{</span><span class="n">name</span><span class="p">}</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<p>Now, to recap, the traditional way to use this class in C# is to declare your using block, and then either a single line with no curly braces, or add curly braces for multi line usage, like this:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">t2</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t2"</span><span class="p">))</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t2</span><span class="p">);</span>
<span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">t3</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t3"</span><span class="p">))</span>
<span class="p">{</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t3</span><span class="p">);</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t3</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">static</span> <span class="k">void</span> <span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">Test</span> <span class="n">test</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"Done something with </span><span class="p">{</span><span class="n">test</span><span class="p">.</span><span class="n">Name</span><span class="p">}</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span></code></pre></figure>
<p>This is fine, but… it does nest your code 1 level deeper which is ok in most cases, but combine this with a couple of if statements and the code becomes pretty messy.</p>
<p>When the end of the declared using block is reached the object is automatically disposed, so we get a printout to the console like this:</p>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">Done something with t2 </p>
<p class="consoletext">ending t2 </p>
<p class="consoletext"> Done something with t3 </p>
<p class="consoletext">ending t3 </p>
</div>
</div>
<h3 id="the-new-sound">The new sound</h3>
<p>You can still use the old way shown above in C# 8, but the new way of declaring usings, is to scope them to your method like this:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">using</span> <span class="nn">var</span> <span class="n">t</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t"</span><span class="p">);</span>
<span class="k">using</span> <span class="nn">var</span> <span class="n">t1</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t1"</span><span class="p">);</span>
</code></pre></figure>
<p>This tells the compiler that you want your disposable object to live as long as the scope it is declared in (the method its in). So <code class="language-plaintext highlighter-rouge">t</code> and <code class="language-plaintext highlighter-rouge">t1</code> will automatically get disposed at the end of that method block. So… putting this back into our example we get the following code:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">using</span> <span class="nn">var</span> <span class="n">t</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t"</span><span class="p">);</span>
<span class="k">using</span> <span class="nn">var</span> <span class="n">t1</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t1"</span><span class="p">);</span>
<span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">t2</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t2"</span><span class="p">))</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t2</span><span class="p">);</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t</span><span class="p">);</span>
<span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">t3</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Test</span><span class="p">(</span><span class="s">"t3"</span><span class="p">))</span>
<span class="p">{</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t3</span><span class="p">);</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t3</span><span class="p">);</span>
<span class="p">}</span>
<span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">t1</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">static</span> <span class="k">void</span> <span class="nf">DoSomethingWithTest</span><span class="p">(</span><span class="n">Test</span> <span class="n">test</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"Done something with </span><span class="p">{</span><span class="n">test</span><span class="p">.</span><span class="n">Name</span><span class="p">}</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></figure>
<p>This prints:</p>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">Done something with t2 </p>
<p class="consoletext">ending t2 </p>
<p class="consoletext">Done something with t </p>
<p class="consoletext">Done something with t3 </p>
<p class="consoletext">Done something with t3 </p>
<p class="consoletext">ending t3 </p>
<p class="consoletext">Done something with t1 </p>
<p class="consoletext">ending t1 </p>
<p class="consoletext">ending t </p>
</div>
</div>
<p>First of all, I personally feel like the syntax and usage of <code class="language-plaintext highlighter-rouge">t</code> and <code class="language-plaintext highlighter-rouge">t1</code> are much cleaner and more natural, theres no nestings to worry about, and you can clearly see they’re being “scoped” because of the using block. In terms of the behaviour here, our t2 and t3 instances end much sooner than the t1, and t instances, and the t1 and t instances are automatically disposed without us having to declare when this happens. Other than that, we can use the variables in much the same way as with traditional usings, we just don’t have to worry about where they get disposed.</p>
<h2 id="finally">Finally</h2>
<p>Personally I much prefer the new using syntax, it feels cleaner without the additional nesting and feels like the language is moving in the right way (away from verbosity), hopefully you do too.</p>Intro C# 8 unfortunately seems to be branching away from the standard .Net Framework and its not (fully?) compatible with the full .Net Framework, instead you have to use DotNetCore to get the benefits of it.Use the Option FORCE ORDER Luke (Sparingly) to tune queries in SqlServer2019-11-09T00:00:00+00:002019-11-09T00:00:00+00:00http://www.garethrepton.com/SqlServer%20Option%20Force%20Order<h2 id="intro">Intro</h2>
<p>I came across Option FORCE ORDER a few months ago whilst looking into performance issues with a particular query, and thought it was worth writing down as I’d never seen it before and its quite useful.</p>
<h2 id="why-option-force-order">Why OPTION FORCE ORDER?</h2>
<p>I had what appeared to be everything correctly lined up for an efficient query plan to be generated, we selected from the smallest data volume table at the start of the query, and then joined to a couple of larger volume tables further down. However, SqlServers query plan was picking an inefficient plan that involved pulling far more data than it needed to from the larger tables before filtering them down to the initial smaller volume tables. Ordinarily at this point I’d usually be thinking about breaking apart the query to ‘trick’ the query plan generator into producing a better query, or using temporary tables etc… However, I got to thinking, surely SQL Server has a query hint for this, and sure enough, there it was in the <a href="https://docs.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-query?view=sql-server-ver15">Documentation</a>.</p>
<p>OPTION FORCE ORDER specifies that the join order of the query should be preserved during query optimisation (as specified by MSDN), this means in my case the query plan changed and generated the plan based on the smaller table, then joining to the larger tables, massively reducing the query time and load.</p>
<p>So for a rough example, lets say we have the following tables:</p>
<ul>
<li>Person - 100 rows</li>
<li>Order - 200,000,000 rows</li>
<li>Invoice - 200,000,000 rows</li>
</ul>
<p>And you have the following query:</p>
<figure class="highlight"><pre><code class="language-sql" data-lang="sql"><span class="k">Select</span> <span class="o">*</span> <span class="k">from</span> <span class="n">Person</span> <span class="n">p</span>
<span class="k">inner</span> <span class="k">join</span> <span class="k">Order</span> <span class="n">o</span> <span class="k">on</span> <span class="n">p</span><span class="p">.</span><span class="n">Id</span> <span class="o">=</span> <span class="n">o</span><span class="p">.</span><span class="n">PersonId</span>
<span class="k">inner</span> <span class="k">join</span> <span class="n">Invoice</span> <span class="n">I</span> <span class="k">on</span> <span class="n">o</span><span class="p">.</span><span class="n">Id</span> <span class="o">=</span> <span class="n">I</span><span class="p">.</span><span class="n">InvoiceId</span>
<span class="k">Where</span> <span class="n">I</span><span class="p">.</span><span class="n">InvoiceReference</span> <span class="o">=</span> <span class="o">@</span><span class="n">InvoiceReference</span></code></pre></figure>
<p>In my case, for some reason the query plan was starting at the invoice table, then linking to order, and then finally linking to person. Assuming the reference filter on the invoice table is more costly than filtering based on people first, this is the wrong way round (your mileage may vary here). Your query will be iterating/scanning/seeking far more rows than it needs to and performing a potentially expensive operation on them.</p>
<p>So… what happens if we add our option to the end:</p>
<figure class="highlight"><pre><code class="language-sql" data-lang="sql"><span class="k">Select</span> <span class="o">*</span> <span class="k">from</span> <span class="n">Person</span> <span class="n">p</span>
<span class="k">inner</span> <span class="k">join</span> <span class="k">Order</span> <span class="n">o</span> <span class="k">on</span> <span class="n">p</span><span class="p">.</span><span class="n">Id</span> <span class="o">=</span> <span class="n">o</span><span class="p">.</span><span class="n">PersonId</span>
<span class="k">inner</span> <span class="k">join</span> <span class="n">Invoice</span> <span class="n">I</span> <span class="k">on</span> <span class="n">o</span><span class="p">.</span><span class="n">Id</span> <span class="o">=</span> <span class="n">I</span><span class="p">.</span><span class="n">InvoiceId</span>
<span class="k">Where</span> <span class="n">I</span><span class="p">.</span><span class="n">InvoiceReference</span> <span class="o">=</span> <span class="o">@</span><span class="n">InvoiceReference</span>
<span class="k">OPTION</span> <span class="p">(</span><span class="k">FORCE</span> <span class="k">ORDER</span><span class="p">)</span></code></pre></figure>
<p>In this case, the query plan inverts from its previous incarnation, and starts with the smaller person table, filtering down the order and invoice result sets BEFORE running the potentially expensive filter on the invoice reference field. Again, assuming the invoice reference filter is expensive, this can massively improve the performance of our query.</p>
<h2 id="finally">Finally</h2>
<p>Hopefully this helps summarise what OPTION FORCE ORDER does, and how it can be of use. Tuning sql queries is a bit of an art form, so if you do ever decide to add a hint to a query, make sure you understand its effects on your query first.</p>Intro I came across Option FORCE ORDER a few months ago whilst looking into performance issues with a particular query, and thought it was worth writing down as I’d never seen it before and its quite useful.F# handling the option type2019-02-02T00:00:00+00:002019-02-02T00:00:00+00:00http://www.garethrepton.com/Fsharp%20handling%20the%20option%20type<h2 id="intro">Intro</h2>
<p>The steady march towards learning F# continues. This time lets look at the option type, what it is, how it compares to nullables in C# and the basics of how you are supposed to deal with it. I originally started this post because I was dealing with option in a lot of my exploratory code, and the things I’ve read online about options implied they were special in some ways, but the further through I got the more I realise they are really just the F# version of the <code class="language-plaintext highlighter-rouge">Nullable</code> type in C#, its how they are handled functionally thats special.</p>
<h2 id="first-the-c-nullable-type">First the C# Nullable type</h2>
<p>The closest relative to the option type in C# world is the <code class="language-plaintext highlighter-rouge">Nullable<T></code> type. Which allows you to declare something thats not assignable to Null (e.g. an <code class="language-plaintext highlighter-rouge">int</code>) as nullable, and has properties that declare whether the variable is assigned a value or not, and gives you access to the value. For example:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="kt">int</span><span class="p">?</span> <span class="n">test</span> <span class="p">=</span> <span class="k">null</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span><span class="n">test</span><span class="p">.</span><span class="n">HasValue</span><span class="p">)</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"</span><span class="p">{</span><span class="n">test</span><span class="p">.</span><span class="n">Value</span><span class="p">}</span><span class="s">"</span><span class="p">);</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">*Prints nothing*</p>
</div>
</div>
<p>This piece of code will do absolutely nothing, because it declares the <code class="language-plaintext highlighter-rouge">Nullable<int></code> “test” with the shorthand <code class="language-plaintext highlighter-rouge">?</code> operator. It then proceeds not to assign anything to test, and to check its <code class="language-plaintext highlighter-rouge">HasValue</code> property to see if its <code class="language-plaintext highlighter-rouge">Null</code>. If it wasn’t <code class="language-plaintext highlighter-rouge">Null</code> it would then print its value to the screen. Now we could of course not do this null check like so:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="kt">int</span><span class="p">?</span> <span class="n">test</span> <span class="p">=</span> <span class="k">null</span><span class="p">;</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"</span><span class="p">{</span><span class="n">test</span><span class="p">.</span><span class="n">Value</span><span class="p">}</span><span class="s">"</span><span class="p">);</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">System.InvalidOperationException: 'Nullable object must have a value.'</p>
</div>
</div>
<p>Of course, this code will throw an exception, which is one step further than the first code that did nothing. Finally, just for completeness:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="kt">int</span><span class="p">?</span> <span class="n">test</span> <span class="p">=</span> <span class="m">1</span><span class="p">;</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"</span><span class="p">{</span><span class="n">test</span><span class="p">.</span><span class="n">Value</span><span class="p">}</span><span class="s">"</span><span class="p">);</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">1</p>
</div>
</div>
<p>This prints the value 1, because thats whats been assigned to the nullable int. So how does this relate to F#?</p>
<h2 id="on-to-f-options">On to F# options</h2>
<p>Well, functional languages don’t tend to work with nulls, instead they deal with something called a <code class="language-plaintext highlighter-rouge">maybe</code> or in F# (and OCAML) world <code class="language-plaintext highlighter-rouge">option</code>. In F# you declare something as an option type by prefixing it with the words <code class="language-plaintext highlighter-rouge">Some</code> for a value or <code class="language-plaintext highlighter-rouge">None</code> for no value. For example:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">=</span> <span class="nc">Some</span> <span class="mi">41</span><span class="p">;</span>
<span class="n">x</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">printfn</span> <span class="s2">"%s"</span> <span class="n">x</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">Some(41)</p>
</div>
</div>
<p>What this piece of code is effectively saying is that x may contain an integer value of 41, BUT consumers of this variable need to make sure they handle the case where it doesn’t exist. Fortunately for our example case above, theres an automatic conversion to a string for the option type and we got “Some(41)” printed to the console.</p>
<p>Just to show the <code class="language-plaintext highlighter-rouge">None</code> case:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">=</span> <span class="nc">None</span><span class="p">;</span>
<span class="n">x</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">printfn</span> <span class="s2">"%s"</span> <span class="n">x</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">*Prints nothing*</p>
</div>
</div>
<p>We’ve assigned None, and we got nothing printed, as you’d expect as long as the string conversions works correctly.</p>
<p>This is almost like for like how <code class="language-plaintext highlighter-rouge">Nullable</code> works in C#, except F# explicitly prints <code class="language-plaintext highlighter-rouge">Some</code> when converting to a string, and C# doesn’t. So.. if this is the same as a Nullable type in C# it follows that we can’t pass the variable directly to an int parameter:</p>
<p><img src="http://www.garethrepton.com/images/FSharpOptions/2019-01-28_18-51-12.png" alt="failstocompile" /></p>
<p>And that turns out to be true, the compiler has rejected this code because the type <code class="language-plaintext highlighter-rouge">option</code> and <code class="language-plaintext highlighter-rouge">int</code> are incompatible for the <code class="language-plaintext highlighter-rouge">+</code> operator. So how should we handle an optional type then?</p>
<h2 id="the-old-bad-nullable-style-handling">The old (bad) nullable style handling</h2>
<p>Of course, we could handle this case the same way as we do with <code class="language-plaintext highlighter-rouge">Nullable</code> in C#. Option provides the methods</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">IsSome</code></li>
<li><code class="language-plaintext highlighter-rouge">IsNone</code></li>
<li><code class="language-plaintext highlighter-rouge">Value</code></li>
</ul>
<p>These work in much the same way as <code class="language-plaintext highlighter-rouge">HasValue</code> and <code class="language-plaintext highlighter-rouge">Value</code>, and calling the <code class="language-plaintext highlighter-rouge">Value</code> function without first checking if there is a value will result in an exception.</p>
<p><img src="http://www.garethrepton.com/images/FSharpOptions/NullError.png" alt="nullerror" /></p>
<p>You could work away using these, writing if statements just like in imperative languages, but because this is the functional world, we don’t have to do that, instead we can use some of the built in language features to assist us to work in a way where exceptions can’t really happen, and <code class="language-plaintext highlighter-rouge">None</code> values are checked at compile time.</p>
<h2 id="pattern-matching">Pattern matching</h2>
<p>One of the really powerful features in F# is pattern matching. Its pretty useful for handling <code class="language-plaintext highlighter-rouge">option</code>, its sort of a really concise switch statement. We can change our add function from above that failed to compile to correctly handle our option:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">=</span> <span class="nc">Some</span> <span class="mi">41</span><span class="p">;</span>
<span class="k">let</span> <span class="n">addOption</span> <span class="n">x</span> <span class="n">y</span> <span class="p">:</span> <span class="kt">int</span> <span class="p">=</span> <span class="k">match</span> <span class="n">x</span> <span class="k">with</span>
<span class="p">|</span> <span class="nc">None</span> <span class="p">-></span> <span class="mi">0</span> <span class="o">+</span> <span class="n">y</span>
<span class="p">|</span> <span class="nc">Some</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>
<span class="k">let</span> <span class="n">y</span> <span class="p">=</span> <span class="n">addOption</span> <span class="n">x</span> <span class="mi">9</span><span class="p">;</span>
<span class="n">y</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">printfn</span> <span class="s2">"%s"</span> <span class="n">x</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">50</p>
</div>
</div>
<p>This time, we’ve handled that option type by creating a function called <code class="language-plaintext highlighter-rouge">addOption</code>, all that function does is decide how to handle the logic of adding the two numbers together, either with a default value for the <code class="language-plaintext highlighter-rouge">None</code> case, or with the actual value. The pattern matching syntax looks a little weird at first, but you get used to it, its basically <code class="language-plaintext highlighter-rouge">match <variable> with |</code> where <code class="language-plaintext highlighter-rouge">|</code> is the separator for each case. Within the first case we match x with <code class="language-plaintext highlighter-rouge">None</code>, this is our condition where x isn’t set, so we declare it as <code class="language-plaintext highlighter-rouge">0 + y</code>, which has no effect. In our second case, we say <code class="language-plaintext highlighter-rouge">Some x</code> which checks that x has a value, and then we use x as a standard integer value in the corresponding function.</p>
<p>This is slightly different to how we’d have handled this in C#, you wouldn’t normally reach for the switch statement in this situation. However in functional land, functions, and the match statement are so easy to create, small and concise that this code makes a lot more sense. Its also quite reusable now, you can use this for adding any optional <code class="language-plaintext highlighter-rouge">int</code>, and avoid the possibility of exceptions due to improper handling of the option.</p>
<p>Of course we can also refactor this code into a higher order function, and make it much more reusable.</p>
<h2 id="the-higher-order-function-version">The higher order function version</h2>
<p>Higher order functions are functions that take another function and operate over that function and associated data. For C# developers probably the easiest example is a Lambda <code class="language-plaintext highlighter-rouge">Select</code> statement, e.g.</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="kt">var</span> <span class="n">items</span> <span class="p">=</span> <span class="k">new</span><span class="p">[]</span> <span class="p">{</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">,</span> <span class="m">4</span><span class="p">,</span> <span class="m">5</span><span class="p">,</span> <span class="m">6</span><span class="p">};</span>
<span class="n">items</span><span class="p">.</span><span class="nf">Select</span><span class="p">(</span><span class="n">x</span> <span class="p">=></span> <span class="n">x</span><span class="p">.</span><span class="nf">ToString</span><span class="p">());</span></code></pre></figure>
<p>The select function, is equivalent to F# map, it takes the <code class="language-plaintext highlighter-rouge">items</code> and applies a function <code class="language-plaintext highlighter-rouge">x => x.ToString()</code> to each item. The important thing to understand here is that <code class="language-plaintext highlighter-rouge">x => x.ToString()</code> is just a function we define and are passing to the <code class="language-plaintext highlighter-rouge">Select</code> function, the <code class="language-plaintext highlighter-rouge">Select</code> function itself will just consist of the functionality to apply the passed function to the items array. So <code class="language-plaintext highlighter-rouge">Select</code> is a higher order function, it doesn’t do much by itself, but it facilitates doing many different things to our items collection just by taking that function as an argument.</p>
<p>Back to our F# then, lets assume we want to multiply our optional numbers as well. We know that for an addition our Identity (i.e. the empty case if you remember about <a href="http://www.garethrepton.com/Category-Theory-Monoids/">monoids</a>) 0, as any <code class="language-plaintext highlighter-rouge">value + 0</code> will just return the original value. For multiplication, our Identity is 1 because 1 multiplied by any value just returns the original value too. So we need to pass in our identity, we also need to pass in the function for the operation (either + or -):</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">=</span> <span class="nc">Some</span> <span class="mi">41</span><span class="p">;</span>
<span class="c1">//1</span>
<span class="k">let</span> <span class="n">optionOperation</span> <span class="n">identity</span> <span class="n">func</span> <span class="n">x</span> <span class="n">y</span> <span class="p">=</span> <span class="k">match</span> <span class="n">x</span> <span class="k">with</span>
<span class="p">|</span> <span class="nc">None</span> <span class="p">-></span> <span class="n">func</span> <span class="n">identity</span> <span class="n">y</span>
<span class="p">|</span> <span class="nc">Some</span> <span class="n">x</span> <span class="p">-></span> <span class="n">func</span> <span class="n">x</span> <span class="n">y</span>
<span class="c1">//2 </span>
<span class="k">let</span> <span class="n">add</span> <span class="p">=</span> <span class="n">optionOperation</span> <span class="mi">0</span> <span class="o">(+)</span>
<span class="k">let</span> <span class="n">multiply</span> <span class="p">=</span> <span class="n">optionOperation</span> <span class="mi">1</span> <span class="o">(*)</span>
<span class="c1">//3</span>
<span class="n">add</span> <span class="n">x</span> <span class="mi">9</span>
<span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span>
<span class="n">multiply</span> <span class="n">x</span> <span class="mi">2</span>
<span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">"50"</p>
<p class="consoletext">"82"</p>
</div>
</div>
<ol>
<li>So in this code we’ve renamed <code class="language-plaintext highlighter-rouge">addOption</code> to <code class="language-plaintext highlighter-rouge">optionOperation</code> and added two preceeding arguments, <code class="language-plaintext highlighter-rouge">identity</code> and <code class="language-plaintext highlighter-rouge">func</code>. <code class="language-plaintext highlighter-rouge">identity</code> takes our default value for an operation for when our value is null. <code class="language-plaintext highlighter-rouge">func</code> is our operation. We then use pretty much the same code as <code class="language-plaintext highlighter-rouge">addOption</code>, but we replace the + with func before the two arguments <code class="language-plaintext highlighter-rouge">func x y</code> and in our <code class="language-plaintext highlighter-rouge">None</code> case we pass the identity.</li>
<li>These two lines are where the magic happens, we partially apply our <code class="language-plaintext highlighter-rouge">optionOperation</code> function for add and multiply. For <code class="language-plaintext highlighter-rouge">add</code> we pass 0 as our Identity and we wrap the plus infix operator in brackets <code class="language-plaintext highlighter-rouge">(+)</code> which turns it into a normal function that can be passed as an argument. We do exactly the same for the multiply, but with 1 and <code class="language-plaintext highlighter-rouge">(*)</code>.</li>
<li>Finally in 3 we call our <code class="language-plaintext highlighter-rouge">add</code> and <code class="language-plaintext highlighter-rouge">multiply</code> functions (which are now functions in their own right), and pipe them through to be printed.</li>
</ol>
<blockquote>
<p><em>Our add and multiply function are also <a href="http://www.garethrepton.com/Category-Theory-Monoids/">monoids</a></em></p>
</blockquote>
<p>This is quite a neat solution, and it means we can reuse our option logic for different types too if we want. The <code class="language-plaintext highlighter-rouge">optionOperation</code> can really run on any type now, with an identity and a function to apply. Lets append a function that concatenates two strings:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">concat</span> <span class="p">=</span> <span class="n">optionOperation</span> <span class="nn">String</span><span class="p">.</span><span class="nc">Empty</span> <span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="n">y</span> <span class="p">-></span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span><span class="p">)</span>
<span class="k">let</span> <span class="n">z</span> <span class="p">=</span> <span class="nc">Some</span> <span class="s2">"I have been "</span>
<span class="n">concat</span> <span class="n">z</span> <span class="s2">"concatenated"</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">"I have been concatenated"</p>
</div>
</div>
<h2 id="null-should-not-be-used-if-its-empty-its-an-option">Null should not be used, if its empty, its an option</h2>
<p>An important major distinction between F# and C# is that nothing should really be assigned <code class="language-plaintext highlighter-rouge">NULL</code> . Instead <code class="language-plaintext highlighter-rouge">option</code> is used, for everything, if it might not exist it is an option, and the compiler mostly forces you to handle the empty case, although as discussed not if you revert to the functions on option itself. In contrast in C# only types that can’t inherently be null can be dealt with explicitly using the <code class="language-plaintext highlighter-rouge">Nullable<T></code> type. Although C# 8 is about to add an option to change that.</p>
<p>For an example of F# allowing the use of option everywhere, heres a Tuple:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">=</span> <span class="nc">Some</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span> <span class="s2">"Fred"</span><span class="p">)</span>
<span class="n">x</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="n">printf</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">"Some((1, 2, 3, Fred))"</p>
</div>
</div>
<p>And we get the printed “Some” value as expected. And if you wanted to use the value within the tuple, you can pattern match just like with standard types. e.g.</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">=</span> <span class="nc">Some</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span> <span class="s2">"Fred"</span><span class="p">)</span>
<span class="n">x</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span>
<span class="k">let</span> <span class="n">isFred</span> <span class="n">x</span> <span class="p">=</span> <span class="k">match</span> <span class="n">x</span> <span class="k">with</span>
<span class="p">|</span> <span class="nc">None</span> <span class="p">-></span> <span class="bp">false</span>
<span class="p">|</span> <span class="nc">Some</span> <span class="o">(_,_,_,</span><span class="n">d</span> <span class="p">:</span> <span class="kt">string</span><span class="p">)</span> <span class="p">-></span> <span class="n">d</span> <span class="p">=</span> <span class="s2">"Fred"</span>
<span class="k">let</span> <span class="n">y</span> <span class="p">=</span> <span class="n">isFred</span> <span class="n">x</span> <span class="p">|></span> <span class="kt">string</span>
<span class="n">y</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span>
<span class="k">let</span> <span class="n">z</span> <span class="p">=</span> <span class="n">isFred</span> <span class="nc">None</span> <span class="p">|></span> <span class="kt">string</span>
<span class="n">z</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">"Some((1, 2, 3, Fred))"</p>
<p class="consoletext">"True"</p>
<p class="consoletext">"False"</p>
</div>
</div>
<p>Note: Here we use _ in our pattern match for the <code class="language-plaintext highlighter-rouge">tuple</code> which denotes that we don’t care about that particular value.</p>
<h2 id="built-in-helper-functions">Built in helper functions</h2>
<p><code class="language-plaintext highlighter-rouge">option</code> also has its own set of helper functions in the <a href="https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/core.option-module-%5Bfsharp%5D">Option</a> module. These assist in the processing of option types much like the standard list operations a couple of examples are:</p>
<h3 id="optionmap"><code class="language-plaintext highlighter-rouge">Option.map</code></h3>
<p><em>applies a function to the option where the value exists:</em></p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">:</span> <span class="kt">int</span> <span class="n">option</span> <span class="p">=</span> <span class="nc">Some</span> <span class="mi">1</span>
<span class="k">let</span> <span class="n">x1</span> <span class="p">:</span> <span class="kt">int</span> <span class="n">option</span> <span class="p">=</span> <span class="nc">None</span>
<span class="n">x</span> <span class="p">|></span> <span class="nn">Option</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span><span class="p">)</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span>
<span class="n">x1</span> <span class="p">|></span> <span class="nn">Option</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span><span class="p">)</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">Some "1"</p>
<p class="consoletext">null</p>
</div>
</div>
<p>Interestingly this prints <null>, but its actually not null its an option type with a value of `None` (thanks to reddit user mongreldog for pointing this out)as the following example shows:</null></p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">:</span> <span class="kt">int</span> <span class="n">option</span> <span class="p">=</span> <span class="nc">Some</span> <span class="mi">1</span>
<span class="k">let</span> <span class="n">x1</span> <span class="p">:</span> <span class="kt">int</span> <span class="n">option</span> <span class="p">=</span> <span class="nc">None</span>
<span class="n">x</span> <span class="p">|></span> <span class="nn">Option</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span><span class="p">)</span> <span class="p">|></span> <span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span><span class="p">.</span><span class="nc">IsNone</span><span class="p">)</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span>
<span class="n">x1</span> <span class="p">|></span> <span class="nn">Option</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span><span class="p">)</span> <span class="p">|></span> <span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span><span class="p">.</span><span class="nc">IsNone</span><span class="o">)|></span> <span class="n">printfn</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">false</p>
<p class="consoletext">true</p>
</div>
</div>
<h3 id="optionget"><code class="language-plaintext highlighter-rouge">Option.get</code></h3>
<p><em>returns the value stored in the option.</em></p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">x</span> <span class="p">:</span> <span class="kt">int</span> <span class="n">option</span> <span class="p">=</span> <span class="nc">Some</span> <span class="mi">1</span>
<span class="k">let</span> <span class="n">x1</span> <span class="p">:</span> <span class="kt">int</span> <span class="n">option</span> <span class="p">=</span> <span class="nc">None</span>
<span class="n">x</span> <span class="p">|></span> <span class="nn">Option</span><span class="p">.</span><span class="n">get</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span>
<span class="n">x1</span> <span class="p">|></span> <span class="nn">Option</span><span class="p">.</span><span class="n">get</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">1</p>
</div>
</div>
<p><img src="http://www.garethrepton.com/images/FSharpOptions/optiongetnull.png" alt="optiongetnull" /></p>
<p>This prints 1 then throws an exception, presumably because its just calling x.Value inside that method, similarly to the map, this is not really ideal behaviour and I think I’d rather use a specific pattern match.</p>
<h3 id="defaultarg">defaultArg</h3>
<p>Another particular function of interest is <code class="language-plaintext highlighter-rouge">defaultArg</code>, which gets you the value or default for the option you pass.</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="n">defaultArg</span> <span class="nc">None</span> <span class="mi">0</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span>
<span class="n">defaultArg</span> <span class="p">(</span><span class="nc">Some</span> <span class="mi">1</span><span class="p">)</span> <span class="mi">0</span> <span class="p">|></span> <span class="kt">string</span> <span class="p">|></span> <span class="n">printfn</span> <span class="s2">"%A"</span></code></pre></figure>
<div class="consolenosize">
<div class="consolebody">
<p class="consoletext">"0"</p>
<p class="consoletext">"1"</p>
</div>
</div>
<p>There are a whole bunch of other method types available, I won’t list them all, but if you use them, its probably worth working out their behaviour for the <code class="language-plaintext highlighter-rouge">None</code> case. Its more functional to avoid nulls and exceptions, and with the tools at your disposal to do this, theres not really a reason not to.</p>
<h2 id="summary">Summary</h2>
<p>After all this, they’re a lot like nullables really aren’t they. F# Just provides much better tools to handle them, as long as you avoid the exception causing/null returning functions.</p>Intro The steady march towards learning F# continues. This time lets look at the option type, what it is, how it compares to nullables in C# and the basics of how you are supposed to deal with it. I originally started this post because I was dealing with option in a lot of my exploratory code, and the things I’ve read online about options implied they were special in some ways, but the further through I got the more I realise they are really just the F# version of the Nullable type in C#, its how they are handled functionally thats special.The solution to FSharp missing .Net Framework Projects in Visual Studio2019-01-22T00:00:00+00:002019-01-22T00:00:00+00:00http://www.garethrepton.com/Fsharp%20missing%20.Net%20Framework%20Projects%20in%20Visual%20Studio<p>I went to create a .Net framework F# console app as part of a larger existing .Net Framework solution, and found that the project dialog didn’t give me that option for a full .Net Framework project. I thought this was a bit weird, so did some googling and found that you have to install the <strong>F# Desktop Language Support pack</strong>.</p>
<p>To do this, in the main Visual Studio menu go to:</p>
<blockquote>
<p>Tools > Get Tools and Features.</p>
</blockquote>
<p>On the installer dialog that appears select the “Individual Components” tab and find F# desktop language support:</p>
<p><img src="http://www.garethrepton.com/images/FSharpInstall/FSharpInstaller.png" alt="installer" /></p>
<p>Then install that as a new feature.</p>
<p>Once installed, back in visual studio you should see:</p>
<p><img src="http://www.garethrepton.com/images/FSharpInstall/FSharpProjects.png" alt="projects" /></p>
<p>Console Application, and Library will allow the selection of a standard .Net Framework project. This is ideal for integrating into existing code.</p>I went to create a .Net framework F# console app as part of a larger existing .Net Framework solution, and found that the project dialog didn’t give me that option for a full .Net Framework project. I thought this was a bit weird, so did some googling and found that you have to install the F# Desktop Language Support pack.Reduce unit test friction patterns - 5 - Autofixture as an automatic Test Data Builder2019-01-07T00:00:00+00:002019-01-07T00:00:00+00:00http://www.garethrepton.com/Reduce-unit-test-friction-patterns%20-%205%20-%20Autofixture%20as%20an%20automatic%20Test%20Data%20Builder<h2 id="the-problem">The Problem</h2>
<p>This is largely the same problem as the <a href="http://www.garethrepton.com/Reduce-unit-test-friction-patterns-4-Test-Data-Builder/">Test Data Builder</a>, you have non trivial test data that needs repeated construction in many tests. I’m going to modify the example here though so it fits the use case of autofixture a little better, so we now have Lion and Rabbit Animal classes that we instantiate rather than just using a type on the Animal object:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp">
<span class="p">[</span><span class="n">Fact</span><span class="p">]</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">GivenMeatFeedsAllLions</span><span class="p">()</span>
<span class="p">{</span>
<span class="c1">//Arrange</span>
<span class="kt">var</span> <span class="n">zoo</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Zoo</span><span class="p">();</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">Add</span><span class="p">(</span><span class="k">new</span> <span class="nf">Lion</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">"Leo"</span><span class="p">));</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">Add</span><span class="p">(</span><span class="k">new</span> <span class="nf">Lion</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">"Graham"</span><span class="p">));</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">Add</span><span class="p">(</span><span class="k">new</span> <span class="nf">Lion</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">"Jeff"</span><span class="p">));</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">Add</span><span class="p">(</span><span class="k">new</span> <span class="nf">Rabbit</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">"Roger"</span><span class="p">));</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">Add</span><span class="p">(</span><span class="k">new</span> <span class="nf">Rabbit</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">"Peter"</span><span class="p">));</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">Add</span><span class="p">(</span><span class="k">new</span> <span class="nf">Rabbit</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">"Fred"</span><span class="p">));</span>
<span class="c1">//Act</span>
<span class="n">zoo</span><span class="p">.</span><span class="nf">Feed</span><span class="p">(</span><span class="s">"Meat"</span><span class="p">);</span>
<span class="c1">//Assert</span>
<span class="kt">var</span> <span class="n">lions</span> <span class="p">=</span> <span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="n">OfType</span><span class="p"><</span><span class="n">Lion</span><span class="p">>();</span>
<span class="kt">var</span> <span class="n">rabbits</span> <span class="p">=</span> <span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="n">OfRabbit</span><span class="p"><</span><span class="n">Lion</span><span class="p">>();</span>
<span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">lion</span> <span class="k">in</span> <span class="n">lions</span><span class="p">)</span>
<span class="n">lion</span><span class="p">.</span><span class="n">IsFed</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">BeTrue</span><span class="p">();</span>
<span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">rabbit</span> <span class="k">in</span> <span class="n">rabbits</span><span class="p">)</span>
<span class="n">rabbit</span><span class="p">.</span><span class="n">IsFed</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">BeFalse</span><span class="p">();</span>
<span class="p">}</span>
</code></pre></figure>
<p>So we have a zoo, which houses animals, each animal is its own type, but each one also has a Name field which must be passed to the constructor which we don’t care about in this particular test. Each one implements a Feed and IsFed method which I’ll leave to the readers imagination as to how they work.</p>
<p>Now.. the test data builder solution is to create a builder to construct your test objects, so your test now looks like :</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="p">[</span><span class="n">Fact</span><span class="p">]</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">GivenMeatFeedsAllLions</span><span class="p">()</span>
<span class="p">{</span>
<span class="c1">//Arrange</span>
<span class="kt">var</span> <span class="n">zoo</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">ZooBuilder</span><span class="p">().</span><span class="nf">WithLions</span><span class="p">(</span><span class="s">"Test"</span><span class="p">,</span> <span class="m">3</span><span class="p">).</span><span class="nf">WithRabbits</span><span class="p">(</span><span class="s">"Roger"</span><span class="p">,</span><span class="m">3</span><span class="p">).</span><span class="nf">Build</span><span class="p">();</span>
<span class="c1">//Act</span>
<span class="n">zoo</span><span class="p">.</span><span class="nf">Feed</span><span class="p">(</span><span class="s">"Meat"</span><span class="p">);</span>
<span class="c1">//Assert</span>
<span class="kt">var</span> <span class="n">lions</span> <span class="p">=</span> <span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="n">OfType</span><span class="p"><</span><span class="n">Lion</span><span class="p">>();</span>
<span class="kt">var</span> <span class="n">rabbits</span> <span class="p">=</span> <span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="n">OfRabbit</span><span class="p"><</span><span class="n">Lion</span><span class="p">>();</span>
<span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">lion</span> <span class="k">in</span> <span class="n">lions</span><span class="p">)</span>
<span class="n">lion</span><span class="p">.</span><span class="n">IsFed</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">BeTrue</span><span class="p">();</span>
<span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">rabbit</span> <span class="k">in</span> <span class="n">rabbits</span><span class="p">)</span>
<span class="n">rabbit</span><span class="p">.</span><span class="n">IsFed</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">BeFalse</span><span class="p">();</span>
<span class="p">}</span>
</code></pre></figure>
<p>We choose not to bother setting the name in the builder, and just have it create 3 of each type of animal, then the rest of the test continues as the previous test did. In this case, the builder requires less code in the test, and is more readable, but will take a lot more code to create the builder itself and unless you have a complex object model, the trade off isn’t always worth it.</p>
<h2 id="the-autofixture-solution">The Autofixture Solution</h2>
<p>This is where a test object creation tool like <a href="https://github.com/AutoFixture/AutoFixture">Autofixture</a> comes in extremely handy. Basically it is a generic test data builder, so you can tell it to create many objects of a given type, give it the amount you want it to create, and it will use internal (customisable) algorithms to create that number pseudo random objects, so for strings an example would be:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="kt">var</span> <span class="n">strings</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Fixture</span><span class="p">().</span><span class="n">CreateMany</span><span class="p"><</span><span class="kt">string</span><span class="p">>(</span><span class="m">20</span><span class="p">);</span></code></pre></figure>
<p>This will create an enumerable of 20 strings, each populated according to its current configuration. It will also work with more complicated objects too:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="k">public</span> <span class="k">class</span> <span class="nc">Person</span>
<span class="p">{</span>
<span class="k">public</span> <span class="kt">string</span> <span class="n">Name</span> <span class="p">{</span><span class="k">get</span><span class="p">;}</span>
<span class="k">public</span> <span class="n">DateTime</span> <span class="n">DateOfBirth</span> <span class="p">{</span><span class="k">get</span><span class="p">;}</span>
<span class="k">public</span> <span class="nf">Person</span><span class="p">(</span><span class="kt">string</span> <span class="n">name</span><span class="p">,</span> <span class="n">DateTime</span> <span class="n">dateOfBirth</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">this</span><span class="p">.</span><span class="n">Name</span> <span class="p">=</span> <span class="n">name</span><span class="p">;</span>
<span class="k">this</span><span class="p">.</span><span class="n">DateOfBirth</span> <span class="p">=</span> <span class="n">dateOfBirth</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="kt">var</span> <span class="n">people</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Fixture</span><span class="p">().</span><span class="n">CreateMany</span><span class="p"><</span><span class="n">Person</span><span class="p">>(</span><span class="m">5</span><span class="p">);</span></code></pre></figure>
<p>AutoFixture will automatically generate 5 Person objects in this code. The names will be pseudo random sequences of characters, and the birth dates won’t make sense, but this can still be useful data in a test scenario.</p>
<p>Using Autofixture allowed us to reduce the amount of setup code required for the string nad Person examples above, lets see how this looks with the Zoo example:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="p">[</span><span class="n">Fact</span><span class="p">]</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">GivenMeatFeedsAllLions</span><span class="p">()</span>
<span class="p">{</span>
<span class="c1">//Arrange</span>
<span class="kt">var</span> <span class="n">fixture</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Fixture</span><span class="p">();</span>
<span class="kt">var</span> <span class="n">zoo</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Zoo</span><span class="p">();</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">AddRange</span><span class="p">(</span><span class="n">fixture</span><span class="p">.</span><span class="n">CreateMany</span><span class="p"><</span><span class="n">Lion</span><span class="p">>(</span><span class="m">3</span><span class="p">));</span>
<span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="nf">AddRange</span><span class="p">(</span><span class="n">fixture</span><span class="p">.</span><span class="n">CreateMany</span><span class="p"><</span><span class="n">Rabbit</span><span class="p">>(</span><span class="m">3</span><span class="p">));</span>
<span class="c1">//Act</span>
<span class="n">zoo</span><span class="p">.</span><span class="nf">Feed</span><span class="p">(</span><span class="s">"Meat"</span><span class="p">);</span>
<span class="c1">//Assert</span>
<span class="kt">var</span> <span class="n">lions</span> <span class="p">=</span> <span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="n">OfType</span><span class="p"><</span><span class="n">Lion</span><span class="p">>();</span>
<span class="kt">var</span> <span class="n">rabbits</span> <span class="p">=</span> <span class="n">zoo</span><span class="p">.</span><span class="n">Animals</span><span class="p">.</span><span class="n">OfRabbit</span><span class="p"><</span><span class="n">Lion</span><span class="p">>();</span>
<span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">lion</span> <span class="k">in</span> <span class="n">lions</span><span class="p">)</span>
<span class="n">lion</span><span class="p">.</span><span class="n">IsFed</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">BeTrue</span><span class="p">();</span>
<span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">rabbit</span> <span class="k">in</span> <span class="n">rabbits</span><span class="p">)</span>
<span class="n">rabbit</span><span class="p">.</span><span class="n">IsFed</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">BeFalse</span><span class="p">();</span>
<span class="p">}</span></code></pre></figure>
<p>This will generate 3 lions and 3 rabbits, all with pseudo random names, the random names will automatically get piped into each objects constructor, and we don’t need to worry about setting the name field that we’re not interested in for this test.
There is slightly more code in the test than with a dedicated builder object, but we do away with maintaining a separate builder object completely, and we’ve reduced the original setup code by several lines. This makes autofixture incredibly powerful as a simple test object builder, and in many cases you can create your model objects without having to worry about the parameters you are not explicitly testing for (just like our name field in the Animal object in the above test).</p>
<h2 id="where-it-applies">Where it applies</h2>
<p>Autofixture as a data builder is pretty useful for objects in tests where the value of the objects doesn’t have to be specific, it just needs to be the correct type, or in cases where the test data objects have a bunch of constructor parameters that you don’t really care about (i.e. the name in the above example). Autofixture also makes a good internal addition to a TestDataBuilder, for when you want to have more automatic ways to generate certain objects, but still want to keep a more readable interface for the test itself.</p>
<h2 id="where-it-probably-shouldnt-apply">Where it probably shouldn’t apply</h2>
<p>Autofixture is not as good in places where you need to have very specific values for test data objects. I generally find if I am trying to heavily customise the standard AutoFixture algorithms (i.e. start defining weird sequences of numbers, or a bunch of valid strings that can be set) the tests can actually become more complicated than they would do by just writing the test data construction code manually. Customizations can be standardised though, so in some cases, its well worth creating a customisation for a commonly used type and reusing that in many tests.</p>
<h2 id="summary">Summary</h2>
<p>AutoFixture functions as an incredibly powerful automatic test data builder, but its automatability is both a blessing and a curse, if used sparingly in simpler scenarios it can really improve your test code by reducing the amount of filler code you have to write, if used in more complex scenarios it can be more complicated than manually creating the data, and somewhat obfuscate the readability of the tests.</p>
<p>AutoFixture is well worth the effort of learning and having in your toolkit, when it does apply, it really is a time saver, just remember that it doesn’t apply everywhere.</p>The Problem This is largely the same problem as the Test Data Builder, you have non trivial test data that needs repeated construction in many tests. I’m going to modify the example here though so it fits the use case of autofixture a little better, so we now have Lion and Rabbit Animal classes that we instantiate rather than just using a type on the Animal object:Async tests with NSubstitute and XUnit in C#2018-12-19T00:00:00+00:002018-12-19T00:00:00+00:00http://www.garethrepton.com/Unit%20Testing%20async%20methods<h2 id="intro">Intro</h2>
<p>This is just a really quick post on how to write async test methods in C# with XUnit and NSubstitute. Thankfully its quite simple these days, and is very useful to know as async calls become more and more commonplace.</p>
<h2 id="so-how-do-you-do-it">So how do you do it?</h2>
<p>Say you have interface IA:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">public</span> <span class="k">interface</span> <span class="nc">IA</span>
<span class="p">{</span>
<span class="n">Task</span><span class="p"><</span><span class="kt">int</span><span class="p">></span> <span class="nf">DoSomething</span><span class="p">();</span>
<span class="p">}</span></code></pre></figure>
<p>Which is called by:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">public</span> <span class="k">class</span> <span class="nc">IAmUnderTest</span>
<span class="p">{</span>
<span class="k">public</span> <span class="k">async</span> <span class="n">Task</span><span class="p"><</span><span class="kt">int</span><span class="p">></span> <span class="nf">GetInt</span><span class="p">(</span><span class="n">IA</span> <span class="n">a</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">return</span> <span class="k">await</span> <span class="n">a</span><span class="p">.</span><span class="nf">DoSomething</span><span class="p">();</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<h2 id="mocking">Mocking</h2>
<p>Because Async methods just return tasks, all you need to do to mock <code class="language-plaintext highlighter-rouge">DoSomething()</code> with NSubstitute is use <code class="language-plaintext highlighter-rouge">Task.FromResult(<YourNumberHere>)</code>. Then the calling code gets a task back that it can still <code class="language-plaintext highlighter-rouge">await</code> and get back the integer result.</p>
<p>So mocking it with NSubstitute looks like this:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">public</span> <span class="k">class</span> <span class="nc">ATest</span>
<span class="p">{</span>
<span class="p">[</span><span class="n">Fact</span><span class="p">]</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">DoesSomething</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">var</span> <span class="n">dependency</span> <span class="p">=</span> <span class="n">Substitute</span><span class="p">.</span><span class="n">For</span><span class="p"><</span><span class="n">IA</span><span class="p">>();</span>
<span class="n">dependency</span><span class="p">.</span><span class="nf">DoSomething</span><span class="p">().</span><span class="nf">Returns</span><span class="p">(</span><span class="n">Task</span><span class="p">.</span><span class="nf">FromResult</span><span class="p">(</span><span class="m">1</span><span class="p">));</span>
<span class="kt">var</span> <span class="n">target</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">IAmUnderTest</span><span class="p">();</span>
<span class="kt">var</span> <span class="n">id</span> <span class="p">=</span> <span class="n">target</span><span class="p">.</span><span class="nf">GetInt</span><span class="p">(</span><span class="n">dependency</span><span class="p">).</span><span class="n">Result</span><span class="p">;</span>
<span class="n">id</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">Be</span><span class="p">(</span><span class="m">1</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<p>So its not very different to usual, you just need that Task.FromResult around the returns method.</p>
<h2 id="async-test-methods">Async Test Methods</h2>
<p>We can go one step further than this, and make the actual test async, because <a href="https://bradwilson.typepad.com/blog/2012/01/xunit19.html">XUnit 1.9 + has support for this</a>. This allows us to get rid of the .Result (shudder) from the tests and the method looks more like any other async method you might write:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">public</span> <span class="k">class</span> <span class="nc">ATest</span>
<span class="p">{</span>
<span class="p">[</span><span class="n">Fact</span><span class="p">]</span>
<span class="k">public</span> <span class="k">async</span> <span class="n">Task</span> <span class="nf">DoesSomethingAsync</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">var</span> <span class="n">dependency</span> <span class="p">=</span> <span class="n">Substitute</span><span class="p">.</span><span class="n">For</span><span class="p"><</span><span class="n">IA</span><span class="p">>();</span>
<span class="n">dependency</span><span class="p">.</span><span class="nf">DoSomething</span><span class="p">().</span><span class="nf">Returns</span><span class="p">(</span><span class="n">Task</span><span class="p">.</span><span class="nf">FromResult</span><span class="p">(</span><span class="m">1</span><span class="p">));</span>
<span class="kt">var</span> <span class="n">target</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">IAmUnderTest</span><span class="p">();</span>
<span class="kt">var</span> <span class="n">id</span> <span class="p">=</span> <span class="k">await</span> <span class="n">target</span><span class="p">.</span><span class="nf">GetInt</span><span class="p">(</span><span class="n">dependency</span><span class="p">);</span>
<span class="n">id</span><span class="p">.</span><span class="nf">Should</span><span class="p">().</span><span class="nf">Be</span><span class="p">(</span><span class="m">1</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<p>Both of these tests pass, and I think I favour the latter as its a bit more natural when testing async methods, and quite frankly seeing <code class="language-plaintext highlighter-rouge">.Result</code> is enough to give anyone nightmares whos come across the myriad of deadlocks it can cause.</p>Intro This is just a really quick post on how to write async test methods in C# with XUnit and NSubstitute. Thankfully its quite simple these days, and is very useful to know as async calls become more and more commonplace.FSharp - Category Theory - Monoid2018-12-15T00:00:00+00:002018-12-15T00:00:00+00:00http://www.garethrepton.com/Category%20Theory%20-%20Monoids<h2 id="introduction">Introduction</h2>
<p>This is the first post on category theory terms, which is sort of like a mathematical version of design patterns in the functional world, but as you might expect they are at a much lower level than the OO design patterns.</p>
<p>One particularly weird thing to get your head around with category theory terms, is they don’t apply to the data type or the function in isolation. They apply to the function over a given data type, so its worth bearing this in mind when you read about category theory.</p>
<h2 id="what-is-a-monoid">What is a Monoid?</h2>
<p>The short description is:</p>
<blockquote>
<p><em>A monoid is an operation on a datatype which is binary, associative and has an identity</em></p>
</blockquote>
<p>Now, this is one of those sentences with a heap of stuff in that makes no sense unless you define it, so lets unpack that a bit:</p>
<h2 id="binary-operation">Binary operation</h2>
<p>To be a binary operation simply means takes to inputs of a set, and produces an output from the same set e.g.</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">add</span> <span class="n">x</span> <span class="n">y</span> <span class="p">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>
<span class="k">let</span> <span class="n">multiply</span> <span class="n">x</span> <span class="n">y</span> <span class="p">=</span> <span class="n">x</span> <span class="p">*</span> <span class="n">y</span></code></pre></figure>
<p>but these are not binary operations because the output type is not of the same set as the inputs (unless the inputs are strings that is):</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">addToString</span> <span class="n">x</span> <span class="n">y</span> <span class="p">=</span> <span class="p">(</span><span class="n">x</span> <span class="o">+</span> <span class="n">y</span><span class="o">).</span><span class="nc">ToString</span><span class="bp">()</span>
<span class="k">let</span> <span class="n">multiplyToString</span> <span class="n">x</span> <span class="n">y</span> <span class="p">=</span> <span class="p">(</span><span class="n">x</span> <span class="p">*</span> <span class="n">y</span><span class="o">).</span><span class="nc">ToString</span><span class="bp">()</span></code></pre></figure>
<h2 id="associative-operation">Associative operation</h2>
<p>To be an associative operation means that the order of application doesn’t matter. So for example adding 3 integers <code class="language-plaintext highlighter-rouge">(1 + 2) + 3 = 6</code> produces the same output written as <code class="language-plaintext highlighter-rouge">1 + (2 + 3) = 6</code> and thats true for all types of addition. The same is also true for multiplication so <code class="language-plaintext highlighter-rouge">4 * (2 * 3) = 24</code> and <code class="language-plaintext highlighter-rouge">(4 * 2) * 3 = 24</code>.</p>
<h2 id="the-identity">The Identity</h2>
<p>Identity in category theory world means a value that does nothing (i.e. returns the original value). So for example <code class="language-plaintext highlighter-rouge">1 + 0 = 1</code> or <code class="language-plaintext highlighter-rouge">2 * 1 = 2</code>. That is literally all the identity is, its a value which when applied to the data type and function returns the original input.</p>
<h2 id="examples-of-monoids">Examples of Monoids</h2>
<p>So we’ve already seen the simplest and most obvious examples these are:</p>
<ul>
<li>Add</li>
</ul>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="c1">//definition</span>
<span class="mi">4</span> <span class="o">+</span> <span class="p">(</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">3</span><span class="p">)</span> <span class="p">=</span> <span class="mi">9</span>
<span class="p">(</span><span class="mi">4</span> <span class="o">+</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="mi">3</span> <span class="p">=</span> <span class="mi">9</span>
<span class="p">(</span><span class="mi">4</span> <span class="o">+</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="mi">3</span> <span class="o">+</span> <span class="mi">0</span> <span class="p">=</span> <span class="mi">9</span> <span class="c1">//Identity = 0</span></code></pre></figure>
<ul>
<li>Multiply</li>
</ul>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="mi">4</span> <span class="p">*</span> <span class="p">(</span><span class="mi">2</span> <span class="p">*</span> <span class="mi">3</span><span class="p">)</span> <span class="p">=</span> <span class="mi">24</span>
<span class="p">(</span><span class="mi">4</span> <span class="p">*</span> <span class="mi">2</span><span class="p">)</span> <span class="p">*</span> <span class="mi">3</span> <span class="p">=</span> <span class="mi">24</span>
<span class="p">(</span><span class="mi">4</span> <span class="p">*</span> <span class="mi">2</span><span class="p">)</span> <span class="p">*</span> <span class="mi">3</span> <span class="p">*</span> <span class="mi">1</span> <span class="p">=</span> <span class="mi">24</span> <span class="c1">//Identity = 1</span></code></pre></figure>
<p>String concatenation also fits too:</p>
<ul>
<li>String concatenation</li>
</ul>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="s2">"A"</span> <span class="o">+</span> <span class="p">(</span><span class="s2">"B"</span> <span class="o">+</span> <span class="s2">"C"</span><span class="p">)</span> <span class="p">=</span> <span class="s2">"ABC"</span>
<span class="p">(</span><span class="s2">"A"</span> <span class="o">+</span> <span class="s2">"B"</span><span class="p">)</span> <span class="o">+</span> <span class="s2">"C"</span> <span class="p">=</span> <span class="s2">"ABC"</span>
<span class="p">(</span><span class="s2">"A"</span> <span class="o">+</span> <span class="s2">"B"</span><span class="p">)</span> <span class="o">+</span> <span class="s2">"C"</span> <span class="o">+</span> <span class="s2">""</span> <span class="p">=</span> <span class="s2">"ABC"</span> <span class="c1">//Identity = ""</span></code></pre></figure>
<p>All of these comply with our above rules. And are pretty straightforward.</p>
<h2 id="examples-of-things-that-arent-monoids">Examples of things that aren’t Monoids</h2>
<ul>
<li>Subtraction</li>
</ul>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="c1">//definition</span>
<span class="mi">4</span> <span class="p">-</span> <span class="p">(</span><span class="mi">2</span> <span class="p">-</span> <span class="mi">3</span><span class="p">)</span> <span class="p">=</span> <span class="mi">5</span>
<span class="p">(</span><span class="mi">4</span> <span class="p">-</span> <span class="mi">2</span><span class="p">)</span> <span class="p">-</span> <span class="mi">3</span> <span class="p">=</span> <span class="p">-</span><span class="mi">1</span></code></pre></figure>
<p>Subtraction doesn’t apply because it isn’t associative, changing the order of the subtraction matters.</p>
<ul>
<li>Division</li>
</ul>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="mi">4</span> <span class="o">/</span> <span class="p">(</span><span class="mi">4</span> <span class="o">/</span> <span class="mi">2</span><span class="p">)</span> <span class="p">=</span> <span class="mi">2</span>
<span class="p">(</span><span class="mi">4</span> <span class="o">/</span> <span class="mi">2</span><span class="p">)</span> <span class="o">/</span> <span class="mi">4</span> <span class="p">=</span> <span class="mi">0</span></code></pre></figure>
<p>Similar to subtraction, division is not associative.</p>
<h2 id="summary">Summary</h2>
<p>Thats just about it, after thinking about what a monoid is and how it applies to code for a bit I suspect they’ll start appearing like when learning about design patterns, it takes a little while to familiarise yourself to the terminology and what to look for. Its a bit harder in this case because the concept is slightly more abstract and the terminology doesn’t really imply what it means to anybody except mathematicians.</p>
<h2 id="a-few-resources-ive-readused">A few resources I’ve read/used</h2>
<p>Mostly I’ve been listening to the category theory episodes of the lambdacast podcast to learn these techniques, but have also read the following blog posts too:</p>
<ul>
<li><a href="https://soundcloud.com/lambda-cast">LambdaCast</a></li>
<li><a href="http://blog.ploeh.dk/2017/10/06/monoids/">Mark Seemann’s blog</a></li>
<li><a href="https://fsharpforfunandprofit.com/posts/monoids-without-tears/">FSharp for fun and profit</a></li>
</ul>Introduction This is the first post on category theory terms, which is sort of like a mathematical version of design patterns in the functional world, but as you might expect they are at a much lower level than the OO design patterns.FSharp - Currying and Partial Application2018-12-01T00:00:00+00:002018-12-01T00:00:00+00:00http://www.garethrepton.com/Partial%20Application<h2 id="introduction">Introduction</h2>
<p>A little bit of magic from the functional world…</p>
<p>Read the following 2 examples closely.</p>
<p>This produces the number 3 in F#:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="k">let</span> <span class="n">add</span> <span class="n">x</span> <span class="n">y</span> <span class="p">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>
<span class="k">let</span> <span class="n">r</span> <span class="p">=</span> <span class="n">add</span> <span class="mi">1</span> <span class="mi">2</span><span class="p">;</span></code></pre></figure>
<p><em>Example 1</em></p>
<p>This code also produces the number 3 in F#:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="k">let</span> <span class="n">add</span> <span class="n">x</span> <span class="n">y</span> <span class="p">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>
<span class="k">let</span> <span class="n">partialAdd</span> <span class="p">=</span> <span class="n">add</span> <span class="mi">1</span>
<span class="k">let</span> <span class="n">r</span> <span class="p">=</span> <span class="n">partialAdd</span> <span class="mi">2</span></code></pre></figure>
<p><em>Example 2</em></p>
<p>The second solution is using something called partial application, and its a bit weird for us OO developers.</p>
<h2 id="what-is-partial-application">What is partial application?</h2>
<p>Partial application is the act of partially applying a function to create a new function and is allowed in functional languages because they do currying.</p>
<h3 id="currying">Currying</h3>
<p>Currying is where every function in a language is executed as though it actually has only 1 argument, so in the case of add above it actually executes like this <code class="language-plaintext highlighter-rouge">(Add 1) + 2</code> where <code class="language-plaintext highlighter-rouge">(Add 1)</code> is the first function, and <code class="language-plaintext highlighter-rouge">x + 2</code> is the second function where <code class="language-plaintext highlighter-rouge">x</code> is the result of <code class="language-plaintext highlighter-rouge">(Add 1)</code>. Each time you call a function with a parameter, you get back a new function unless you’ve specified all of the parameters for the function. If we supply all the arguments the first time we call the function like we do in the first example, the currying is transparent and we get the value back that is the result of the <code class="language-plaintext highlighter-rouge">add</code>, so <code class="language-plaintext highlighter-rouge">r = 3</code>, but internally the currying will still take place.</p>
<h3 id="partial-application">Partial application</h3>
<p>Currying allows for partial application of functions, so we can supply any function an incomplete number of arguments, but “bake-in” arguments that we don’t want to supply each time, and we get back a new function that we can call with the reduced number of parameters. So <code class="language-plaintext highlighter-rouge">let partialAdd = add 1</code> actually just returns a new function with a single int parameter called <code class="language-plaintext highlighter-rouge">partialAdd</code> with the parameter 1 baked into it because we haven’t supplied all of the arguments to complete the function call. Subsequently calling this new function with the argument 2, completes the function call and adds the baked-in 1 to 2 and returns the int value 3.</p>
<h2 id="why-is-this-useful">Why is this useful?</h2>
<p>To think about this as a C# or OO developer, it opens up a whole new level of composition that we you can’t really get in non-functional languages. Its at a much lower level than we’re used to, and it allows incredibly succinct composition of behaviours that we’d end up writing classes and interfaces for normally. Lets write some code and see how it helps in a simplistic logging scenario.</p>
<h3 id="a-simple-log-example">A simple log example</h3>
<p>For a simple example, lets consider a case where you want to write a performance log to the console. So after a series of events in your application you want to output roughly how long they took to execute with a uniform message. Now in C# world this looks something like this:</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="k">void</span> <span class="nf">Main</span><span class="p">()</span>
<span class="p">{</span>
<span class="nf">Log</span><span class="p">(</span><span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">,</span> <span class="s">$"First"</span><span class="p">);</span>
<span class="n">Thread</span><span class="p">.</span><span class="nf">Sleep</span><span class="p">(</span><span class="m">1000</span><span class="p">);</span>
<span class="nf">Log</span><span class="p">(</span><span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">,</span> <span class="s">$"Second"</span><span class="p">);</span>
<span class="n">Thread</span><span class="p">.</span><span class="nf">Sleep</span><span class="p">(</span><span class="m">1000</span><span class="p">);</span>
<span class="nf">Log</span><span class="p">(</span><span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">,</span> <span class="s">$"Third"</span><span class="p">);</span>
<span class="n">Thread</span><span class="p">.</span><span class="nf">Sleep</span><span class="p">(</span><span class="m">1000</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">Log</span><span class="p">(</span><span class="n">DateTime</span> <span class="n">time</span><span class="p">,</span> <span class="kt">string</span> <span class="n">message</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"</span><span class="p">{</span><span class="n">time</span><span class="p">}</span><span class="s"> - </span><span class="p">{</span><span class="n">message</span><span class="p">}</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span></code></pre></figure>
<p><em>Printing</em>:</p>
<ul>
<li>30/11/2018 18:30:52 - First</li>
<li>30/11/2018 18:30:53 - Second</li>
<li>30/11/2018 18:30:54 - Third</li>
</ul>
<p>A direct conversion in F# is something like:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">sleep</span> <span class="n">x</span> <span class="p">=</span> <span class="nn">Async</span><span class="p">.</span><span class="nc">Sleep</span> <span class="n">x</span> <span class="p">|></span> <span class="nn">Async</span><span class="p">.</span><span class="nc">RunSynchronously</span>
<span class="k">let</span> <span class="n">log</span> <span class="n">date</span> <span class="n">message</span><span class="p">=</span> <span class="n">printfn</span> <span class="s2">"%s %s"</span> <span class="n">date</span> <span class="n">message</span>
<span class="k">let</span> <span class="n">getDate</span> <span class="p">=</span> <span class="nn">DateTime</span><span class="p">.</span><span class="nn">Now</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span>
<span class="n">log</span> <span class="n">getDate</span> <span class="s2">"First"</span>
<span class="n">sleep</span> <span class="mi">1000</span>
<span class="n">log</span> <span class="n">getDate</span> <span class="s2">"Second"</span>
<span class="n">sleep</span> <span class="mi">1000</span>
<span class="n">log</span> <span class="n">getDate</span> <span class="s2">"Third"</span>
<span class="n">sleep</span> <span class="mi">1000</span> </code></pre></figure>
<p><em>Printing</em>:</p>
<ul>
<li>30/11/2018 18:34:50 first</li>
<li>30/11/2018 18:34:50 second</li>
<li>30/11/2018 18:34:50 third</li>
</ul>
<p>OK, so far very similar really.</p>
<p><strong>Wait</strong>… all those times are the same in the F# example?</p>
<h3 id="function-calls-are-not-always-re-evaluated">Function calls are not always re-evaluated</h3>
<p>This is something that tripped me up at first writing this, but theres a reason for it, when you call a function without arguments the value it returns is bound to the function call, it does not get re-executed. If you call a function with arguments the function gets bound to the variable, so each time you call it, it will re-execute. Now in our case, we have no arguments, so we will need to supply the <code class="language-plaintext highlighter-rouge">Unit</code> type to the function, which means using <code class="language-plaintext highlighter-rouge">()</code> as the single argument to the <code class="language-plaintext highlighter-rouge">getDate</code> function, and as the first argument to the partial <code class="language-plaintext highlighter-rouge">logg</code> function to ensure both get re-executed on each call, and we get the right times printed to the log.</p>
<h3 id="partially-applied-version">Partially applied version</h3>
<p>Lets modify the F# version to use the unit parameter and partial application for the log getDate argument:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">sleep</span> <span class="n">x</span> <span class="p">=</span> <span class="nn">Async</span><span class="p">.</span><span class="nc">Sleep</span> <span class="n">x</span> <span class="p">|></span> <span class="nn">Async</span><span class="p">.</span><span class="nc">RunSynchronously</span>
<span class="k">let</span> <span class="n">log</span> <span class="n">date</span> <span class="n">message</span><span class="p">=</span> <span class="n">printfn</span> <span class="s2">"%s %s"</span> <span class="n">date</span> <span class="n">message</span>
<span class="k">let</span> <span class="n">getDate</span> <span class="bp">()</span> <span class="p">=</span> <span class="nn">DateTime</span><span class="p">.</span><span class="nn">Now</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span>
<span class="k">let</span> <span class="n">logg</span> <span class="bp">()</span> <span class="p">=</span> <span class="n">log</span> <span class="p">(</span><span class="n">getDate</span> <span class="bp">()</span><span class="p">)</span>
<span class="n">logg</span> <span class="bp">()</span> <span class="s2">"First"</span>
<span class="n">sleep</span> <span class="mi">1000</span>
<span class="n">logg</span> <span class="bp">()</span> <span class="s2">"Second"</span>
<span class="n">sleep</span> <span class="mi">1000</span>
<span class="n">logg</span> <span class="bp">()</span> <span class="s2">"Third"</span>
<span class="n">sleep</span> <span class="mi">1000</span></code></pre></figure>
<p><em>Printing</em>:</p>
<ul>
<li>01/12/2018 07:12:37 First</li>
<li>01/12/2018 07:12:38 Second</li>
<li>01/12/2018 07:12:39 Third</li>
</ul>
<p>This time things start to look a little different in a couple of ways. The first is that I’ve modified the <code class="language-plaintext highlighter-rouge">logg</code> function and <code class="language-plaintext highlighter-rouge">getDate</code> to take the unit parameter to make sure they re-execute each time and don’t memoize their values, this is slightly less succinct, but acceptable.</p>
<p>The other major difference is that I’ve made the call to log slightly more succinct by creating a new function called logg which is the result of partially applying log with just the getDate part. This same effect could be achieved in C# with an optional parameter on the date argument, and an if statement to set it, but it takes more code, so the F# version is more succinct even in this really simple example. Personally I think the F# version looks much better in this case.</p>
<h3 id="a-more-in-depth-example">A more in-depth example</h3>
<p>Lets make this more complicated and see where it goes, lets make the log method capable of outputting to multiple places (simulating a real logging system like Log4Net etc…).</p>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"><span class="k">void</span> <span class="nf">Main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">var</span> <span class="n">logger</span> <span class="p">=</span> <span class="k">new</span> <span class="nf">Logger</span><span class="p">(</span><span class="k">new</span> <span class="n">ILogWriter</span><span class="p">[]</span> <span class="p">{</span> <span class="k">new</span> <span class="nf">ConsoleLogWriter</span><span class="p">(),</span> <span class="k">new</span> <span class="nf">FakeSqlLogWriter</span><span class="p">()});</span>
<span class="n">logger</span><span class="p">.</span><span class="nf">Log</span><span class="p">(</span><span class="s">"Tester"</span><span class="p">,</span> <span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">,</span> <span class="s">$"First"</span><span class="p">);</span>
<span class="n">Thread</span><span class="p">.</span><span class="nf">Sleep</span><span class="p">(</span><span class="m">1000</span><span class="p">);</span>
<span class="n">logger</span><span class="p">.</span><span class="nf">Log</span><span class="p">(</span><span class="s">"Tester"</span><span class="p">,</span> <span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">,</span> <span class="s">$"Second"</span><span class="p">);</span>
<span class="n">Thread</span><span class="p">.</span><span class="nf">Sleep</span><span class="p">(</span><span class="m">1000</span><span class="p">);</span>
<span class="n">logger</span><span class="p">.</span><span class="nf">Log</span><span class="p">(</span><span class="s">"Tester"</span><span class="p">,</span> <span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">,</span> <span class="s">$"Third"</span><span class="p">);</span>
<span class="n">Thread</span><span class="p">.</span><span class="nf">Sleep</span><span class="p">(</span><span class="m">1000</span><span class="p">);</span>
<span class="p">}</span>
<span class="c1">// Define other methods and classes here</span>
<span class="k">public</span> <span class="k">class</span> <span class="nc">Logger</span>
<span class="p">{</span>
<span class="k">public</span> <span class="n">IEnumerable</span><span class="p"><</span><span class="n">ILogWriter</span><span class="p">></span> <span class="n">Writers</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
<span class="k">public</span> <span class="nf">Logger</span><span class="p">(</span><span class="k">params</span> <span class="n">ILogWriter</span><span class="p">[]</span> <span class="n">writers</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">this</span><span class="p">.</span><span class="n">Writers</span> <span class="p">=</span> <span class="n">writers</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">Log</span><span class="p">(</span><span class="kt">string</span> <span class="n">sender</span><span class="p">,</span> <span class="n">DateTime</span> <span class="n">date</span><span class="p">,</span> <span class="kt">string</span> <span class="n">message</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">writer</span> <span class="k">in</span> <span class="n">Writers</span><span class="p">)</span>
<span class="n">writer</span><span class="p">.</span><span class="nf">Output</span><span class="p">(</span><span class="n">sender</span><span class="p">,</span> <span class="n">date</span><span class="p">.</span><span class="nf">ToString</span><span class="p">(),</span> <span class="n">message</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">interface</span> <span class="nc">ILogWriter</span>
<span class="p">{</span>
<span class="k">void</span> <span class="nf">Output</span><span class="p">(</span><span class="kt">string</span> <span class="n">sender</span><span class="p">,</span> <span class="kt">string</span> <span class="n">time</span><span class="p">,</span> <span class="kt">string</span> <span class="n">message</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">class</span> <span class="nc">ConsoleLogWriter</span> <span class="p">:</span> <span class="n">ILogWriter</span>
<span class="p">{</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">Output</span><span class="p">(</span><span class="kt">string</span> <span class="n">sender</span><span class="p">,</span> <span class="kt">string</span> <span class="n">time</span><span class="p">,</span> <span class="kt">string</span> <span class="n">message</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"</span><span class="p">{</span><span class="n">sender</span><span class="p">}</span><span class="s"> - </span><span class="p">{</span><span class="n">time</span><span class="p">}</span><span class="s"> - </span><span class="p">{</span><span class="n">message</span><span class="p">}</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">class</span> <span class="nc">FakeSqlLogWriter</span> <span class="p">:</span> <span class="n">ILogWriter</span>
<span class="p">{</span>
<span class="k">public</span> <span class="k">void</span> <span class="nf">Output</span><span class="p">(</span><span class="kt">string</span> <span class="n">sender</span><span class="p">,</span> <span class="kt">string</span> <span class="n">time</span><span class="p">,</span> <span class="kt">string</span> <span class="n">message</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">Console</span><span class="p">.</span><span class="nf">WriteLine</span><span class="p">(</span><span class="s">$"IAMSQL: </span><span class="p">{</span><span class="n">sender</span><span class="p">}</span><span class="s"> - </span><span class="p">{</span><span class="n">time</span><span class="p">}</span><span class="s"> - </span><span class="p">{</span><span class="n">message</span><span class="p">}</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<p><strong>54 lines of code</strong></p>
<p><em>Printing</em>:</p>
<ul>
<li>Tester - 30/11/2018 19:02:41 - First</li>
<li>IAMSQL: Tester - 30/11/2018 19:02:41 - First</li>
<li>Tester - 30/11/2018 19:02:42 - Second</li>
<li>IAMSQL: Tester - 30/11/2018 19:02:42 - Second</li>
<li>Tester - 30/11/2018 19:02:43 - Third</li>
<li>IAMSQL: Tester - 30/11/2018 19:02:43 - Third</li>
</ul>
<p>Here I’ve added a sender argument to our log method, moved it into an object, and added an interface for writing the various types of log output. This is pretty typical of a logger implementation in c# world, I’ve added and instantiated 2 writers, the first is our console writer, the second is a fake sql writer which just writes to the console anyway with “IAMSQL” at the start of the message. Quite a lot of code but this is a fairly solid object oriented solution.</p>
<p>Heres the same behaviour in F#:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"><span class="k">let</span> <span class="n">sleep</span> <span class="n">x</span> <span class="p">=</span> <span class="nn">Async</span><span class="p">.</span><span class="nc">Sleep</span> <span class="n">x</span> <span class="p">|></span> <span class="nn">Async</span><span class="p">.</span><span class="nc">RunSynchronously</span>
<span class="k">let</span> <span class="n">logConsole</span> <span class="n">sender</span> <span class="n">date</span> <span class="n">prefix</span> <span class="n">message</span><span class="p">=</span> <span class="n">printfn</span> <span class="s2">"%s%s %s %s"</span> <span class="n">prefix</span> <span class="n">sender</span> <span class="n">date</span> <span class="n">message</span>
<span class="k">let</span> <span class="n">getDate</span> <span class="bp">()</span> <span class="p">=</span> <span class="nn">DateTime</span><span class="p">.</span><span class="nn">Now</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span>
<span class="k">let</span> <span class="n">logConsolePartial</span> <span class="bp">()</span> <span class="p">=</span> <span class="n">logConsole</span> <span class="s2">"Tester"</span> <span class="p">(</span><span class="n">getDate</span><span class="bp">()</span><span class="p">)</span>
<span class="k">let</span> <span class="n">logActualConsole</span> <span class="bp">()</span> <span class="p">=</span> <span class="n">logConsolePartial</span> <span class="bp">()</span> <span class="s2">""</span>
<span class="k">let</span> <span class="n">logFakeSql</span> <span class="bp">()</span> <span class="p">=</span> <span class="n">logConsolePartial</span> <span class="bp">()</span> <span class="s2">"IAMSQL "</span>
<span class="k">let</span> <span class="n">logWriters</span> <span class="p">=</span> <span class="p">[</span><span class="n">logActualConsole</span><span class="p">;</span> <span class="n">logFakeSql</span><span class="p">]</span>
<span class="k">let</span> <span class="n">log</span> <span class="n">message</span> <span class="p">=</span> <span class="n">logWriters</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">iter</span><span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span> <span class="bp">()</span> <span class="n">message</span><span class="p">)</span>
<span class="n">log</span> <span class="s2">"First"</span>
<span class="n">sleep</span> <span class="mi">1000</span>
<span class="n">log</span> <span class="s2">"Second"</span>
<span class="n">sleep</span> <span class="mi">1000</span>
<span class="n">log</span> <span class="s2">"Third"</span>
<span class="n">sleep</span> <span class="mi">1000</span></code></pre></figure>
<p><strong>17 lines of code</strong>.</p>
<p><em>Printing</em>:</p>
<ul>
<li>Tester 01/12/2018 07:19:48 First</li>
<li>IAMSQL Tester 01/12/2018 07:19:48 First</li>
<li>Tester 01/12/2018 07:19:49 Second</li>
<li>IAMSQL Tester 01/12/2018 07:19:49 Second</li>
<li>Tester 01/12/2018 07:19:50 Third</li>
<li>IAMSQL Tester 01/12/2018 07:19:50 Third</li>
</ul>
<p>I’d say thats a pretty good example of how partial application can be beneficial. So instead of using the polymorphic approach we used in C#. Our LogWriters become a list of partially applied functions instead of objects.</p>
<ol>
<li><code class="language-plaintext highlighter-rouge">logConsole</code> is our initial function that actually logs to the console, and accepts a prefix as well as the standard arguments (so we can fake the Sql Log Writer).</li>
<li><code class="language-plaintext highlighter-rouge">logConsolePartial</code> is an intermediate step, we call <code class="language-plaintext highlighter-rouge">logConsole</code> partially with the common arguments we’re going to use throughout this code. In this case, the sender, and the getDate function.</li>
<li><code class="language-plaintext highlighter-rouge">logActualConsole</code> is then a partial function call to <code class="language-plaintext highlighter-rouge">logConsolePartial</code> with no prefix.</li>
<li><code class="language-plaintext highlighter-rouge">logFakeSql</code> is also a partial function call to <code class="language-plaintext highlighter-rouge">logConsolePartial</code> with the IAMSQL prefix.</li>
<li><code class="language-plaintext highlighter-rouge">logWriters</code> is then our list of loggers;</li>
<li>finally <code class="language-plaintext highlighter-rouge">log</code> takes in the message parameter then pipes the list of loggers into an iterator, which calls each in turn with the message passed in.</li>
</ol>
<p>Really what we’ve done here is replaced the strategy pattern we used for the set of ILogWriter’s in C# with a pair of “Strategy” functions. So <code class="language-plaintext highlighter-rouge">FakeSqlLogWriter</code> becomes the function <code class="language-plaintext highlighter-rouge">logFakeSql</code> and <code class="language-plaintext highlighter-rouge">ConsoleLogWriter</code> becomes <code class="language-plaintext highlighter-rouge">logActualConsole</code>. We’ve also replaced the dependency injection with our log function, which takes in the partially applied logFakeSql and logActualConsole functions, and completes their call with the message parameter. <strong>Its like we’re doing object composition, but at the function level, so the “Framework” code required to plumb it all together is massively reduced</strong>. We’re composing functions together here with minimal code, and fuss (except that unit parameter), and its much much more succinct than the c# version, but it still expresses what its doing effectively, probably more effectively than in C# as theres less code to read.</p>
<h2 id="summary">Summary</h2>
<p>Partial application is a functional concept thats made possible because F# uses currying to make sure that all functions actually have a single parameter. Its very powerful (I’m sure there are many weird and wonderful uses for it I’ve not even considered yet), but with this power comes a little extra complexity, I can see the unit parameter being a bit like the deferred execution issues you get with Developers new to Linq. It actually sort of replaces dependency injection in object oriented languages, but is also useful for quite a few more cases. It is yet another tool in F# that allows for writing succinct, yet readable code, something thats very hard to do in C#, especially using pure object oriented features.</p>
<h2 id="a-few-resources-ive-readused">A few resources I’ve read/used</h2>
<p>This started as a simple post about partial application, but turned into a bit more so I’ve read quite a lot to get to this point, here are a few of the resources I’ve used to learn about the concepts:</p>
<ul>
<li><a href="https://soundcloud.com/lambda-cast">LambdaCast (partial application episode)</a></li>
<li><a href="https://fsharpforfunandprofit.com/posts/currying/">Currying</a></li>
<li><a href="https://fsharpforfunandprofit.com/posts/partial-application/">Partial Application</a></li>
<li><a href="https://stackoverflow.com/questions/17870937/what-does-this-notation-mean/17872004#17872004">Information about the unit parameter</a></li>
<li><a href="https://www.linqpad.net/">Linqpad</a></li>
</ul>Introduction A little bit of magic from the functional world…FSharp - Thinking a bit more functionally for a prime number calculator2018-11-17T00:00:00+00:002018-11-17T00:00:00+00:00http://www.garethrepton.com/FSharpPrimeCalculator<h2 id="intro">Intro</h2>
<p>For my second post on F# I’m sticking with simple examples, and I’m going to write a really basic prime number calculator. Again I’m writing this in <a href="https://www.linqpad.net/">linqpad</a> as an “F# program”.</p>
<p>So what is a prime number?</p>
<blockquote>
<p>“A prime number that is divisible only by itself and 1.”</p>
</blockquote>
<p>A nice simple example then… this is not going to try to be a smart mathematical solution to this, its going to be a brute force approach because it will take more code to write, and I’ll have to iterate etc…</p>
<h2 id="the-solution">The Solution</h2>
<p>First of all, a few rules I’ve picked up on F# from reading various sources (primarily the brilliant <a href="https://fsharpforfunandprofit.com">FSharpForFunAndProfit</a>) and experimenting this week:</p>
<ul>
<li><strong>Everything is a function</strong> - Seriously everything, the language sort of forces you into this mindset</li>
<li><strong>Chaining functions is powerful</strong> - Piping the results of one function directly to another is brilliant</li>
<li><strong>Higher order functions are powerful</strong> - These are functions that can operate on other functions, it means common behaviour’s can be packaged together nicely, and not reused</li>
<li><strong>Functions in F# are much, much more succinct that C#</strong> - FSharp does not require the types of declarations that need to be done in C# to pass around functions, most stuff is inferred.</li>
<li><strong>I still don’t quite know what a Monad is</strong> - :)</li>
</ul>
<p>The F# solution I came up with is:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="c1">//1. The actual prime number calculations</span>
<span class="k">let</span> <span class="n">isDivisible</span> <span class="n">a</span> <span class="n">b</span> <span class="p">=</span> <span class="n">a</span> <span class="o">%</span> <span class="n">b</span> <span class="p">=</span> <span class="mi">0</span>
<span class="k">let</span> <span class="n">totalDiv</span> <span class="n">x</span> <span class="p">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">..</span><span class="n">x</span><span class="p">]</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">filter</span><span class="p">(</span><span class="k">fun</span> <span class="n">y</span> <span class="p">-></span> <span class="n">isDivisible</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
<span class="k">let</span> <span class="n">isPrime</span> <span class="n">x</span> <span class="p">=</span> <span class="n">totalDiv</span> <span class="n">x</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">length</span> <span class="p">=</span> <span class="mi">2</span>
<span class="c1">//2. Utility functions, really just to show what its doing</span>
<span class="k">let</span> <span class="n">print</span> <span class="n">x</span> <span class="p">=</span> <span class="n">printfn</span> <span class="s2">"%s"</span> <span class="n">x</span>
<span class="k">let</span> <span class="kt">string</span> <span class="n">x</span> <span class="p">=</span> <span class="n">x</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span>
<span class="k">let</span> <span class="n">concat</span> <span class="n">x</span> <span class="p">=</span> <span class="nn">String</span><span class="p">.</span><span class="n">concat</span> <span class="s2">"</span><span class="se">\r\n</span><span class="s2">"</span> <span class="n">x</span>
<span class="c1">//3. This is the statement that joins the functions together</span>
<span class="p">[</span><span class="mi">2</span><span class="p">..</span><span class="mi">10000</span><span class="p">]</span>
<span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="n">x</span><span class="p">,</span> <span class="n">isPrime</span> <span class="n">x</span><span class="p">)</span>
<span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="k">fun</span> <span class="n">x</span> <span class="p">-></span> <span class="kt">string</span> <span class="n">x</span> <span class="p">)</span>
<span class="p">|></span> <span class="n">concat</span>
<span class="p">|></span> <span class="n">print</span>
</code></pre></figure>
<p>This outputs:</p>
<figure class="highlight"><pre><code class="language-plaintext" data-lang="plaintext"> (2, True)
(3, True)
(4, False)
(5, True)
(6, False)
(7, True)
(8, False)
(9, False)
(10, False)
(11, True)
(12, False)
(13, True)
(14, False)
(15, False)
(16, False)
(17, True)
(18, False)
(19, True)
(20, False)
(21, False)
...
</code></pre></figure>
<ol>
<li>We declare our 3 functions that we need to check if a single number is prime.
<ol>
<li>isDivisible = just checks that dividing 1 number against another has 0 remainder</li>
<li>totalDiv = this one is the functional equivalent of a for loop, it iterates the numbers between 1 and x, and returns those that are divisible without remainder.</li>
<li>isPrime = this calls totalDiv, and checks the result has a count of 2, if it does, by definition it can only be divisible by 1 and itself so is prime.</li>
</ol>
</li>
<li>These are our helper functions effectively, we could write this without those, but it just makes the code a bit clearer</li>
<li>This joins our functions together to calculate all prime numbers between 2 and 10000 by:
<ol>
<li>Generating a list of numbers in the range we care about</li>
<li>Piping that to the map function, that calls isPrime and gives us a result</li>
<li>Piping the results of that to a map function that converts our result to a string.</li>
<li>Piping that to concat (the argument is inferred by the pipe)</li>
<li>Piping that to print (the argument is inferred by the pipe)</li>
</ol>
</li>
</ol>
<h2 id="observations">Observations</h2>
<p>There are some fairly interesting things emerging from this code. EVERYTHING is really a function, and you are encouraged to write very small functions, this leads to a world where everything is also composable. This is a very powerful difference between Functional and OO paradigms, where OO encourages composition in the form of objects, F# encourages composition in the form of functions. You can do some of this in C# by passing around Func<T..>, it just never quite feels right in the language, it always feels like a bit of a hack. Whereas in F#, everything is a Func, and it makes the passing around of functions more natural, but also much more readable than C#. I'm not sure how this looks in a larger application yet, but this also means you could probably write a function once, and use everywhere in the application, especially higher order functions whose argument types could vary with the functions that are passed into them. You can also do this in C# but there are static types, generics, and type arguments that need to be specified, that just feel a bit like they get in the way of it.</T..></p>
<p>Another interesting thing here is that 3. actually just looks a whole lot like a lambda chain in C#. Thats because the Lambda functions in C# are basically a bit of functional declarative programming that C# developers can, and probably do use every day. So thats good news :).</p>
<h2 id="and-finally">And finally</h2>
<p>With these thoughts in mind, I’ve thought of a small refactor that can be made to make this more functional still…</p>
<p>Old code:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="c1">//1. The actual prime number calculations</span>
<span class="k">let</span> <span class="n">isDivisible</span> <span class="n">a</span> <span class="n">b</span> <span class="p">=</span> <span class="n">a</span> <span class="o">%</span> <span class="n">b</span> <span class="p">=</span> <span class="mi">0</span>
<span class="k">let</span> <span class="n">totalDiv</span> <span class="n">x</span> <span class="p">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">..</span><span class="n">x</span><span class="p">]</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">filter</span><span class="p">(</span><span class="k">fun</span> <span class="n">y</span> <span class="p">-></span> <span class="n">isDivisible</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
<span class="k">let</span> <span class="n">isPrime</span> <span class="n">x</span> <span class="p">=</span> <span class="n">totalDiv</span> <span class="n">x</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">length</span> <span class="p">=</span> <span class="mi">2</span>
</code></pre></figure>
<p>New code:</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="c1">//1. The actual prime number calculations</span>
<span class="k">let</span> <span class="n">isDivisible</span> <span class="n">a</span> <span class="n">b</span> <span class="p">=</span> <span class="n">a</span> <span class="o">%</span> <span class="n">b</span> <span class="p">=</span> <span class="mi">0</span>
<span class="k">let</span> <span class="n">matches</span> <span class="n">f</span> <span class="n">x</span> <span class="p">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">..</span><span class="n">x</span><span class="p">]</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">filter</span><span class="p">(</span><span class="k">fun</span> <span class="n">y</span> <span class="p">-></span> <span class="n">f</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
<span class="k">let</span> <span class="n">isPrime</span> <span class="n">x</span> <span class="p">=</span> <span class="n">matches</span> <span class="n">isDivisible</span> <span class="n">x</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">length</span> <span class="p">=</span> <span class="mi">2</span>
</code></pre></figure>
<p>So what did I do? I changed the “totalDiv” function to take in a function, and renamed it to “matches”, I also changed the way it gets called in isPrime to pass the isDivisible function. So we’re then left with three very specific functions that each only care about 1 thing, and “matches” is now very general, we could pass it any function that takes two values and returns a boolean.</p>Intro For my second post on F# I’m sticking with simple examples, and I’m going to write a really basic prime number calculator. Again I’m writing this in linqpad as an “F# program”.Day 1 of functional programming for an OO developer2018-11-10T00:00:00+00:002018-11-10T00:00:00+00:00http://www.garethrepton.com/LetsLearnFSharp<h2 id="letslearnfsharp">lets(learn(fsharp(“”)))</h2>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="k">let</span> <span class="n">lets</span> <span class="n">x</span> <span class="p">=</span> <span class="n">x</span>
<span class="k">let</span> <span class="n">learn</span> <span class="n">x</span> <span class="p">=</span> <span class="n">x</span>
<span class="k">let</span> <span class="n">fsharp</span> <span class="n">x</span> <span class="p">=</span> <span class="s2">"OK"</span>
<span class="k">let</span> <span class="n">res</span> <span class="p">=</span> <span class="n">lets</span><span class="p">(</span><span class="n">learn</span><span class="p">(</span><span class="n">fsharp</span><span class="p">(</span><span class="s2">""</span><span class="o">)))</span>
<span class="n">res</span><span class="p">.</span><span class="nc">Dump</span><span class="bp">()</span><span class="p">;</span>
</code></pre></figure>
<p>Which creates:</p>
<p><img src="http://www.garethrepton.com/images/fsharp1.png" alt="My first f# program" /></p>
<p>My first F# program is a sarcastic post header :).</p>
<h2 id="intro">Intro</h2>
<p>So I’ve decided to learn a bit more about functional programming, the more I hear about it the more I quite like it. I’ve been listening to the excellent <a href="https://twitter.com/lambdacast">LambdaCast</a> and reading some of the articles on <a href="https://fsharpforfunandprofit.com/">FsharpForFunAndProfit</a> and its clear there appears to be some merit to the functional mindset. I’m also quite interested to understand if I’m already using a certain amount of the functional mindset in my c# code.</p>
<p>I’ll probably write the interesting tidbits I spot along the way, as there are plenty of F# tutorials out there.</p>
<h2 id="day-1">Day 1</h2>
<p>Its day 1, what do you do, apart from a sarcastic heading and supporting program for a blog post? Lets write something a bit fruity in c# and in f# and compare them… lets write everyones favourite sample code question, <a href="http://wiki.c2.com/?FizzBuzzTest">FizzBuzz</a> (yay!). Today I’m using <a href="https://www.linqpad.net/">linqpad</a> with the trendy dark mode skin, I might go full hipster and switch to VSCode in the future though.</p>
<p>So the spec (borrowed from the c2 wiki):</p>
<blockquote>
<p>“Write a program that prints the numbers from 1 to 100.
But for multiples of three print “Fizz” instead of the number
and for the multiples of five print “Buzz”.
For numbers which are multiples of both three and five print “FizzBuzz”.”</p>
</blockquote>
<h3 id="c-solution">C# Solution:</h3>
<figure class="highlight"><pre><code class="language-csharp" data-lang="csharp"> <span class="k">void</span> <span class="nf">Main</span><span class="p">()</span>
<span class="p">{</span>
<span class="k">for</span><span class="p">(</span><span class="kt">var</span> <span class="n">i</span> <span class="p">=</span> <span class="m">1</span><span class="p">;</span> <span class="n">i</span> <span class="p"><=</span> <span class="m">100</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span>
<span class="p">{</span>
<span class="nf">FizzItUp</span><span class="p">(</span><span class="n">i</span><span class="p">).</span><span class="nf">Dump</span><span class="p">();</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">static</span> <span class="kt">string</span> <span class="nf">FizzItUp</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">i</span> <span class="p">%</span> <span class="m">15</span> <span class="p">==</span> <span class="m">0</span><span class="p">)</span>
<span class="k">return</span> <span class="s">"FizzBuzz"</span><span class="p">;</span>
<span class="k">else</span> <span class="k">if</span><span class="p">(</span><span class="n">i</span> <span class="p">%</span> <span class="m">3</span> <span class="p">==</span> <span class="m">0</span><span class="p">)</span>
<span class="k">return</span> <span class="s">"Fizz"</span><span class="p">;</span>
<span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">i</span> <span class="p">%</span> <span class="m">5</span> <span class="p">==</span> <span class="m">0</span><span class="p">)</span>
<span class="k">return</span> <span class="s">"Buzz"</span><span class="p">;</span>
<span class="k">else</span>
<span class="k">return</span> <span class="n">i</span><span class="p">.</span><span class="nf">ToString</span><span class="p">();</span>
<span class="p">}</span>
</code></pre></figure>
<h3 id="f-solution-attempt-1">F# solution (attempt 1):</h3>
<p>Heres where I quickly realised I know barely any syntax… but bear with me :).</p>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="k">let</span> <span class="n">fizzItUp</span> <span class="n">i</span> <span class="p">=</span>
<span class="k">if</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">15</span> <span class="p">=</span> <span class="mi">0</span> <span class="k">then</span> <span class="s2">"FizzBuzz"</span>
<span class="k">elif</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">3</span> <span class="p">=</span> <span class="mi">0</span> <span class="k">then</span> <span class="s2">"Fizz"</span>
<span class="k">elif</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">5</span> <span class="p">=</span> <span class="mi">0</span> <span class="k">then</span> <span class="s2">"Buzz"</span>
<span class="k">else</span> <span class="n">i</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span>
<span class="k">for</span> <span class="n">i</span> <span class="p">=</span> <span class="mi">1</span> <span class="k">to</span> <span class="mi">100</span> <span class="k">do</span>
<span class="k">let</span> <span class="n">x</span> <span class="p">=</span> <span class="n">fizzItUp</span> <span class="n">i</span><span class="p">;</span>
<span class="n">x</span><span class="p">.</span><span class="nc">Dump</span><span class="bp">()</span><span class="p">;</span>
</code></pre></figure>
<p>Ok.. so this WORKS and is really succinct and nice I thought, then I read <a href="https://fsharpforfunandprofit.com/posts/control-flow-expressions/">this</a> which says for loops and if then else are imperative and not functional concepts, and as the goal here is to learn functional programming, its immediately time for a rewrite…</p>
<h3 id="f-solution-attempt-2">F# solution (attempt 2):</h3>
<figure class="highlight"><pre><code class="language-fsharp" data-lang="fsharp"> <span class="k">let</span> <span class="n">fizzItUp</span> <span class="n">i</span> <span class="p">=</span>
<span class="k">match</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">15</span> <span class="k">with</span> <span class="mi">0</span> <span class="p">-></span> <span class="s2">"FizzBuzz"</span> <span class="p">|</span> <span class="p">_</span> <span class="k">when</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">3</span> <span class="p">=</span> <span class="mi">0</span> <span class="p">-></span> <span class="s2">"Fizz"</span> <span class="p">|</span> <span class="p">_</span> <span class="k">when</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">5</span> <span class="p">=</span> <span class="mi">0</span> <span class="p">-></span> <span class="s2">"Buzz"</span> <span class="p">|</span> <span class="p">_</span> <span class="p">-></span> <span class="n">i</span><span class="p">.</span><span class="nc">ToString</span><span class="bp">()</span>
<span class="k">let</span> <span class="n">res</span> <span class="p">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">..</span><span class="mi">100</span><span class="p">]</span> <span class="p">|></span> <span class="nn">Seq</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="n">fizzItUp</span><span class="p">)</span>
<span class="n">res</span><span class="p">.</span><span class="nc">Dump</span><span class="bp">()</span>
</code></pre></figure>
<p>This works, and is more declarative than my first attempt, which was than imperative, which is a more functional way of thinking.</p>
<h3 id="observations">Observations</h3>
<p>Look at the succinctness in the final F# example!, its an elegantly small amount of code. Whilst I’m not entirely sure the match feature is that much better than the if in this particular case, I can see how it would be advantageous for things where you have a fixed map between arguments (sort of like a c# switch statement). The sequence logic is much simpler than a for loop, and less verbose and self explanatory, which is also nice.</p>
<p>Its definitely more declerative rather than imperative, you wouldn’t necessarily want to step through this, you’d read it to check it is correct, then run it to test the outcome.</p>
<p>Types are being inferred, theres no specifying them anyway, kind of like var in C# but without even needing that, but there is some control there, these are not dynamic types at all, when I tried to return i without the ToString() from the match statement, there was a compile error stating there was a type mismatch from int to string.</p>
<p>The map function kind of reminds me of lambda statements in c#, it will be interesting to see if parralels continue between F# and the C# linq (lambda) statements going forwards.</p>lets(learn(fsharp(“”)))