Jekyll2023-08-13T12:57:47+00:00http://madusudanan.com/atom.xmlMadusudananEveryday life is like programming, I guess. If you love something you can put beauty into it - Donald KnuthMadusudanan.B.NScala Tutorials Part #30 - Closures2018-06-29T00:00:00+00:002018-06-29T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-closures<h2 id="closures">Closures</h2>
<p>This is part 30 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul fa-lg space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#StateBehaviour">Encapsulating state and behaviour</a></li>
<li><a href="#FreeVariables">Free variables</a></li>
<li><a href="#ReferentialTransparency">Reasoning about referential transparency</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p><a href="https://en.wikipedia.org/wiki/Closure_(computer_programming)" target="_blank">Closure</a> is an important concept in the world of Functional Programming. A considerably simpler definition of a Closure is presented well in this <a href="http://www.jerf.org/iri/post/2542" target="_blank">excellent blog post</a>.</p>
<blockquote>
<p>A closure is a function that you can pass around that retains the same “environment” as the one it had when it was created.</p>
</blockquote>
<p>They are not very unique to Scala, usually they are found in many languages which give emphasis to functions as first class values. To understand closures, let’s understand what object oriented programming offers as a fundamental feature i.e encapsulation of state behaviour.</p>
<h3><b><a name="StateBehaviour" class="inter-header">Encapsulating state and behaviour</a></b></h3>
<p>Let’s take the below simple class.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">class</span> <span class="nc">Person</span> <span class="o">{</span>
<span class="c1">//State - Carries data</span>
<span class="k">var</span> <span class="n">name</span> <span class="k">=</span> <span class="s">"Noname"</span>
<span class="k">var</span> <span class="n">age</span> <span class="k">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="c1">//Encapsulates behaviour</span>
<span class="k">def</span> <span class="nf">setName</span> <span class="o">(</span><span class="n">name</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span class="py">name</span> <span class="k">=</span> <span class="n">name</span>
<span class="o">}</span>
<span class="k">def</span> <span class="nf">setAge</span> <span class="o">(</span><span class="n">age</span><span class="k">:</span><span class="kt">Int</span><span class="o">)</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span class="py">age</span> <span class="k">=</span> <span class="n">age</span>
<span class="o">}</span>
<span class="k">def</span> <span class="nf">getName</span> <span class="o">()</span> <span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="o">{</span>
<span class="n">name</span>
<span class="o">}</span>
<span class="k">def</span> <span class="nf">getAge</span> <span class="o">()</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="o">{</span>
<span class="n">age</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<p>This is a pretty concise definition of an object. It carries the variables which represent state and the methods which encapsulate behaviour.</p>
<p>In functional programming, instead of passing around objects, we pass around functions. But when we compare objects and functions, we can see that functions in general do not carry state and only carry behaviour.</p>
<h3><b><a name="FreeVariables" class="inter-header">Free variables</a></b></h3>
<p>The concept of a <a href="https://en.wikipedia.org/wiki/Free_variables_and_bound_variables" target="_blank">free variable</a> comes from mathematics and functional programming theory. They refer to variables which are used locally but enclosed in some scope such as a class of method.</p>
<p>In the below code, the variable <code class="language-plaintext highlighter-rouge">interest</code> is defined for the class scope.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">interestRate</span> <span class="k">=</span> <span class="mi">10</span>
<span class="k">def</span> <span class="nf">printInterest</span><span class="o">()</span><span class="k">:</span> <span class="kt">Unit</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">println</span><span class="o">(</span><span class="n">interestRate</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>The different between a normal function and a closure is that a closure is dependant on one or more free variables. Let’s expand on our above example.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">var</span> <span class="n">increaseRate</span> <span class="k">=</span> <span class="mf">10.0</span>
<span class="nf">calculateIncreasedAmount</span><span class="o">(</span><span class="mi">1000</span><span class="o">)</span>
<span class="k">def</span> <span class="nf">calculateIncreasedAmount</span><span class="o">(</span><span class="n">amount</span><span class="k">:</span><span class="kt">Double</span><span class="o">)</span><span class="k">:</span> <span class="kt">Unit</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"Increased amount is ${amount * (increaseRate/100)} units"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>Here the variable <code class="language-plaintext highlighter-rouge">increaseRate</code> is a var and can be changed at any point of the program. In the below example, it changes according to the recent state/value of the <code class="language-plaintext highlighter-rouge">increaseRate</code> variable.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">var</span> <span class="n">increaseRate</span> <span class="k">=</span> <span class="mf">10.0</span>
<span class="nf">calculateIncreasedAmount</span><span class="o">(</span><span class="mi">1000</span><span class="o">)</span>
<span class="k">def</span> <span class="nf">calculateIncreasedAmount</span><span class="o">(</span><span class="n">amount</span><span class="k">:</span><span class="kt">Double</span><span class="o">)</span><span class="k">:</span> <span class="kt">Unit</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"Increased amount is ${amount * (increaseRate/100)} units"</span><span class="o">)</span>
<span class="o">}</span>
<span class="n">increaseRate</span> <span class="k">=</span> <span class="mf">20.0</span>
<span class="nf">calculateIncreasedAmount</span><span class="o">(</span><span class="mi">1000</span><span class="o">)</span></code></pre></figure>
<p>At first it prints 100.0 and then 200.0 since the state variable changed.</p>
<h3><b><a name="ReferentialTransparency" class="inter-header">Reasoning about referential transparency</a></b></h3>
<p>We saw how functions can be termed pure if they are referentially transparent in <a href="/blog/scala-tutorials-part-21-referential-transparency/">part 21</a>. Using the same rules mentioned, is the above function/closure refentially transparent? No, because the variable <code class="language-plaintext highlighter-rouge">increaseRate</code> is a var and can be changed anywhere in the flow. If it is a val then it would make the closure referentially transparent and hence pure.</p>
<p>So in order for any closure to be pure, the free variable should be either a val/immutable object. It is good practice to keep the free variable immutable so that the resultant closure is referentially transparent.</p>
<p>In real world Scala usage, you would find that Closures as a language feature is not that extensively used. This is because Scala is a hybrid OO+FP language and developers usually use a combination of Case classes/Case objects along with pure functions. Since Case class are immutable, they still give a good way to deal state while still maintaining things such as referential transparency and not using shared mutable state. Closures are extensively used in pure functional languages such as Haskell, primarily because they are the best way to model state.</p>Madusudanan.B.NClosuresScala Tutorials Part #29 - Design By Contract2017-12-27T00:00:00+00:002017-12-27T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-design-by-contract<h2 id="design-by-contract">Design By Contract</h2>
<p>This is part 29 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul fa-lg space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#Overview">High Level Overview</a></li>
<li><a href="#AssertAssume">Assert and Assume</a></li>
<li><a href="#RequireEnsuring">Require and Ensuring</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p><a href="https://en.wikipedia.org/wiki/Design_by_contract" target="_blank">Design by contract</a> is a programming approach where there are preconditions and post-conditions to a code block and if these conditions are not satisfied an exception is thrown to the caller. This was originally designed by <a href="https://en.wikipedia.org/wiki/Bertrand_Meyer" target="_blank">Betrand Mayer</a> who was the creator of the <a href="https://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_blank">Eiffel programming language</a>.</p>
<p><br />
<img src="/images/dbc.svg" width="400" height="400" /></p>
<p><cite> Picture courtesy - <a href="https://en.wikipedia.org/wiki/Design_by_contract#/media/File:Design_by_contract.svg" target="_blank">Wikipedia</a> </cite></p>
<p>Some languages do not have first class support, some have support through external libraries. Scala has some support through the language itself and that is what this post is all about.</p>
<h3><b><a name="Overview" class="inter-header">High Level Overview</a></b></h3>
<p>Scala has four methods <code class="language-plaintext highlighter-rouge">assert</code>, <code class="language-plaintext highlighter-rouge">assume</code>, <code class="language-plaintext highlighter-rouge">require</code> and <code class="language-plaintext highlighter-rouge">ensuring</code> which are present in the <code class="language-plaintext highlighter-rouge">Predef.scala</code> package and they are available by default and no library import is required.</p>
<p>Of these <code class="language-plaintext highlighter-rouge">assert</code>, <code class="language-plaintext highlighter-rouge">assume</code> and <code class="language-plaintext highlighter-rouge">require</code> are preconditions and <code class="language-plaintext highlighter-rouge">ensuring</code> is a post-condition. Preconditions are meant to be guards before entering a code block while a post condition happens happen after execution i.e like a <code class="language-plaintext highlighter-rouge">do while</code> construct. Code examples below will make them clear.</p>
<h3><b><a name="AssertAssume" class="inter-header">Assert and Assume</a></b></h3>
<p>The <code class="language-plaintext highlighter-rouge">assert</code> keyword would be familiar if you have done unit testing before. It takes in a boolean condition as a parameter and checks if it is true else throws an exception.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">age</span> <span class="k">=</span> <span class="mi">20</span>
<span class="nf">assert</span><span class="o">(</span><span class="n">age</span><span class="o">></span><span class="mi">20</span><span class="o">)</span></code></pre></figure>
<p>This will throw an exception.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nc">Exception</span> <span class="n">in</span> <span class="n">thread</span> <span class="s">"main"</span> <span class="nv">java</span><span class="o">.</span><span class="py">lang</span><span class="o">.</span><span class="py">AssertionError</span><span class="k">:</span> <span class="kt">assertion</span> <span class="kt">failed</span>
<span class="n">at</span> <span class="nv">scala</span><span class="o">.</span><span class="py">Predef$</span><span class="o">.</span><span class="py">assert</span><span class="o">(</span><span class="nv">Predef</span><span class="o">.</span><span class="py">scala</span><span class="k">:</span><span class="err">156</span><span class="o">)</span>
<span class="o">.....</span></code></pre></figure>
<p><code class="language-plaintext highlighter-rouge">assume</code> is very similar.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="nf">grantLicense</span><span class="o">(</span><span class="mi">16</span><span class="o">)</span>
<span class="k">def</span> <span class="nf">grantLicense</span><span class="o">(</span><span class="n">age</span><span class="k">:</span><span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Unit</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">assume</span><span class="o">(</span><span class="n">age</span><span class="o">></span><span class="mi">18</span><span class="o">)</span>
<span class="c1">//Business logic</span></code></pre></figure>
<p>This also throws an exception.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nc">Exception</span> <span class="n">in</span> <span class="n">thread</span> <span class="s">"main"</span> <span class="nv">java</span><span class="o">.</span><span class="py">lang</span><span class="o">.</span><span class="py">AssertionError</span><span class="k">:</span> <span class="kt">assumption</span> <span class="kt">failed</span>
<span class="n">at</span> <span class="nv">scala</span><span class="o">.</span><span class="py">Predef$</span><span class="o">.</span><span class="py">assume</span><span class="o">(</span><span class="nv">Predef</span><span class="o">.</span><span class="py">scala</span><span class="k">:</span><span class="err">185</span><span class="o">)</span>
<span class="o">.....</span></code></pre></figure>
<p>In fact, it throws the same exception <code class="language-plaintext highlighter-rouge">java.lang.AssertionError</code> only with the name changed such as assertion failed or assumption failed depending on what we use. Even the source code is almost identical.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="c1">//Taken from Predef.scala</span>
<span class="c1">//Assert</span>
<span class="k">def</span> <span class="nf">assert</span><span class="o">(</span><span class="n">assertion</span><span class="k">:</span> <span class="kt">Boolean</span><span class="o">)</span> <span class="o">{</span>
<span class="nf">if</span> <span class="o">(!</span><span class="n">assertion</span><span class="o">)</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nv">java</span><span class="o">.</span><span class="py">lang</span><span class="o">.</span><span class="py">AssertionError</span><span class="o">(</span><span class="s">"assertion failed"</span><span class="o">)</span>
<span class="o">}</span>
<span class="c1">//Assume</span>
<span class="k">def</span> <span class="nf">assume</span><span class="o">(</span><span class="n">assumption</span><span class="k">:</span> <span class="kt">Boolean</span><span class="o">)</span> <span class="o">{</span>
<span class="nf">if</span> <span class="o">(!</span><span class="n">assumption</span><span class="o">)</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nv">java</span><span class="o">.</span><span class="py">lang</span><span class="o">.</span><span class="py">AssertionError</span><span class="o">(</span><span class="s">"assumption failed"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>So why the almost identical ones? The answer lies in how they should be used.</p>
<p><code class="language-plaintext highlighter-rouge">assert</code> is kind of like attempting to prove something. It can be regarded as a predicate in a mathematical sense i.e which needs to be checked by the static checker. <code class="language-plaintext highlighter-rouge">assume</code> on the other hand is like an axiom where the code can rely upon the static checker to throw an error if its not true. So they are in some sense just syntactic sugar.</p>
<h3><b><a name="RequireEnsuring" class="inter-header">Require and Ensuring</a></b></h3>
<p>Methods <code class="language-plaintext highlighter-rouge">require</code> and <code class="language-plaintext highlighter-rouge">ensure</code> often work in tandem. Let’s look at an example.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nf">squareEvenNumbersWithLimit</span><span class="o">(</span><span class="n">num</span><span class="k">:</span><span class="kt">Int</span><span class="o">,</span><span class="n">limit</span><span class="k">:</span><span class="kt">Int</span><span class="o">)</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">require</span><span class="o">(</span><span class="n">num</span><span class="o">%</span><span class="mi">2</span><span class="o">==</span><span class="mi">0</span><span class="o">)</span>
<span class="n">num</span> <span class="o">*</span> <span class="n">num</span>
<span class="o">}</span> <span class="nf">ensuring</span><span class="o">(</span><span class="n">num</span> <span class="o">*</span> <span class="n">num</span> <span class="o"><</span> <span class="n">limit</span><span class="o">)</span></code></pre></figure>
<p>This can fail in two ways i.e the passed number is not an even number and also when the squared result is greater than the limit that is passed in.</p>
<p>Calling it with the below parameters,</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nf">squareEvenNumbersWithLimit</span><span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="mi">200</span><span class="o">)</span></code></pre></figure>
<p>Causes a <code class="language-plaintext highlighter-rouge">java.lang.IllegalArgumentException</code>. This blames the caller for giving a value that is termed illegal as per the contract. Notice how this is different from the <code class="language-plaintext highlighter-rouge">java.lang.AssertionError</code>. One is an exception and another is an error. I have already explained this in a previous blog - <a href="/blog/scala-tutorials-part-24-exception-handling/#Intro">exception handling in Scala</a></p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nc">Exception</span> <span class="n">in</span> <span class="n">thread</span> <span class="s">"main"</span> <span class="nv">java</span><span class="o">.</span><span class="py">lang</span><span class="o">.</span><span class="py">IllegalArgumentException</span><span class="k">:</span> <span class="kt">requirement</span> <span class="kt">failed</span>
<span class="n">at</span> <span class="nv">scala</span><span class="o">.</span><span class="py">Predef$</span><span class="o">.</span><span class="py">require</span><span class="o">(</span><span class="nv">Predef</span><span class="o">.</span><span class="py">scala</span><span class="k">:</span><span class="err">212</span><span class="o">)</span>
<span class="o">....</span></code></pre></figure>
<p>If we try to break the ensuring condition,</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nc">Exception</span> <span class="n">in</span> <span class="n">thread</span> <span class="s">"main"</span> <span class="nv">java</span><span class="o">.</span><span class="py">lang</span><span class="o">.</span><span class="py">AssertionError</span><span class="k">:</span> <span class="kt">assertion</span> <span class="kt">failed</span>
<span class="n">at</span> <span class="nv">scala</span><span class="o">.</span><span class="py">Predef$</span><span class="o">.</span><span class="py">assert</span><span class="o">(</span><span class="nv">Predef</span><span class="o">.</span><span class="py">scala</span><span class="k">:</span><span class="err">156</span><span class="o">)</span>
<span class="o">....</span></code></pre></figure>
<p>Turns out that <code class="language-plaintext highlighter-rouge">ensuring</code> calls <code class="language-plaintext highlighter-rouge">assert</code> internally. One more thing to note is that <code class="language-plaintext highlighter-rouge">ensuring</code> cannot access variables inside of the method block. Its scope is limited to the method parameters.</p>
<p><img src="/images/ensuring-error.png" alt="Ensuring error" /></p>
<h3><b><a name="Conclusion" class="inter-header">Conclusion</a></b></h3>
<p>We have briefly seen what these methods can do. These can be combined to form complex design patterns such as Design by Contract, Defensive Programming etc., An important thing to note is that <code class="language-plaintext highlighter-rouge">assert</code> and <code class="language-plaintext highlighter-rouge">assume</code> can be removed using a compiler flag <code class="language-plaintext highlighter-rouge">-Xdisable-assertions</code> during compile time. This is useful when you don’t want such statements to enter into production.</p>
<p>There are advanced patterns possible. Notice that all of these functions in <code class="language-plaintext highlighter-rouge">Predef.scala</code> have another signature where functions can be passed in i.e they are higher order functions.</p>
<p>In the Scala world these patterns are not extensively used. This is because they throw an exception during run time. There are better design patterns where we can encode such conditions during compile time. We have already seen the <a href="/blog/scala-tutorials-part-16-the-option-type/">Option type</a> which is one way of encoding state within a container which is compile time. There are other ways such as <code class="language-plaintext highlighter-rouge">Either</code>, <code class="language-plaintext highlighter-rouge">Try</code> etc., We will take a look at those in later tutorials. With that said, there are situations where you might want to use design by contract, such as dealing with situations where <code class="language-plaintext highlighter-rouge">null</code> is quite possible(interfacing with java code) and then throwing an exception.</p>Madusudanan.B.NDesign By ContractScala Tutorials Part #28 - Getting started with Implicits2017-12-16T00:00:00+00:002017-12-16T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-implicits<h2 id="implicits">Implicits</h2>
<p>This is part 28 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#ImplicitParams">Implicit Variables & Method Parameters</a></li>
<li><a href="#ImplicitFunctions">Implicit Functions</a></li>
<li><a href="#Decompiled">Taking a look at the decompiled code</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p>Implicit in the dictionary means predefined or understood. The <code class="language-plaintext highlighter-rouge">implicit</code> keyword is extensively used in Scala and its important to understand its usage. If used correctly, they can greatly reduce the amount of boilerplate code.</p>
<h3><b><a name="ImplicitParams" class="inter-header">Implicit Variables & Method Parameters</a></b></h3>
<p>Let’s declare a method that takes in an <code class="language-plaintext highlighter-rouge">implicit</code> parameter.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nf">multiply</span><span class="o">(</span><span class="k">implicit</span> <span class="n">param1</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=</span> <span class="n">param1</span> <span class="o">*</span> <span class="n">value</span></code></pre></figure>
<p><code class="language-plaintext highlighter-rouge">value</code> is a variable which the <code class="language-plaintext highlighter-rouge">multiply</code> method has scope to. So let’s just declare a simple variable as below.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">value</span> <span class="k">=</span> <span class="mi">10</span></code></pre></figure>
<p>We will be able to call the <code class="language-plaintext highlighter-rouge">multiply</code> method without any parameters since one of them is <code class="language-plaintext highlighter-rouge">implicit</code> and the other is global. But, it will lead to an error as we have not declared any implicit variables that is suitable for that method.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nf">println</span><span class="o">(</span><span class="n">multiply</span><span class="o">)</span> </code></pre></figure>
<p><img src="/images/implicit_error.png" alt="Implicit error" /></p>
<p>Defining an <code class="language-plaintext highlighter-rouge">implicit</code> variable fixes the error.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">implicit</span> <span class="k">val</span> <span class="nv">param1</span> <span class="k">=</span> <span class="mi">2</span></code></pre></figure>
<p>Now,</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nf">println</span><span class="o">(</span><span class="n">multiply</span><span class="o">)</span></code></pre></figure>
<p>Will print 20.</p>
<p>An interesting thing to note here is that the implicit parameter can be of any name and the method would still work.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">object</span> <span class="nc">RunExample</span> <span class="k">extends</span> <span class="nc">App</span><span class="o">{</span>
<span class="k">val</span> <span class="nv">value</span> <span class="k">=</span> <span class="mi">10</span>
<span class="k">implicit</span> <span class="k">val</span> <span class="nv">anotherValue</span> <span class="k">=</span> <span class="mi">2</span>
<span class="k">def</span> <span class="nf">multiply</span><span class="o">(</span><span class="k">implicit</span> <span class="n">param1</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=</span> <span class="n">param1</span> <span class="o">*</span> <span class="n">value</span>
<span class="c1">//Prints 20</span>
<span class="nf">println</span><span class="o">(</span><span class="n">multiply</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>As you can see, only the variable type is more important rather than the name. At this point, an important question that would come up is what will happen if there are two implicit variables of the same type. Let’s test it out.</p>
<p><img src="/images/two-implicit-error.png" alt="Two implicit variables error" /></p>
<p>The compiler is much more strict here. It could resort to taking the first defined implicit value but it leads to bad/ambiguous code, so it promptly complains here.</p>
<p>Once we declare the first parameter as implicit, anything that follows it is also implicit. The below example makes it more clear.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nf">multiply</span><span class="o">(</span><span class="k">implicit</span> <span class="n">param1</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span><span class="n">param2</span> <span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=</span> <span class="n">param1</span> <span class="o">*</span> <span class="n">param2</span></code></pre></figure>
<p>If we call just <code class="language-plaintext highlighter-rouge">multiply</code> it prints 4 as it takes the value of <code class="language-plaintext highlighter-rouge">anotherValue</code> twice. Usually there will be only one implicit parameter for a method. We cannot call <code class="language-plaintext highlighter-rouge">param2</code> directly here since it is implicit.</p>
<p>It also not possible to make the second parameter <code class="language-plaintext highlighter-rouge">implicit</code>. Such a syntax would lead to a compiler error.</p>
<p><img src="/images/implicit-second-param-error.png" alt="Implicit second param error" /></p>
<h3><b><a name="ImplicitFunctions" class="inter-header">Implicit Functions</a></b></h3>
<p>Just like implicit method parameters, implicit functions are useful in places where we want the compiler to call the method automatically.</p>
<p>Let’s take the below example.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">x</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="mf">20.23</span></code></pre></figure>
<p>This will obviously throw an error.</p>
<p><img src="/images/variable-type-error.png" alt="Variable type error" /></p>
<p>Let’s declare an implicit function that converts <code class="language-plaintext highlighter-rouge">Double</code> to <code class="language-plaintext highlighter-rouge">Int</code>.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">implicit</span> <span class="k">def</span> <span class="nf">doubleToInt</span><span class="o">(</span><span class="n">d</span><span class="k">:</span> <span class="kt">Double</span><span class="o">)</span> <span class="k">=</span> <span class="nv">d</span><span class="o">.</span><span class="py">toInt</span></code></pre></figure>
<p>Now the the above code works as expected i.e it auto converts the <code class="language-plaintext highlighter-rouge">Double</code> to <code class="language-plaintext highlighter-rouge">Int</code>.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">implicit</span> <span class="k">def</span> <span class="nf">doubleToInt</span><span class="o">(</span><span class="n">d</span><span class="k">:</span> <span class="kt">Double</span><span class="o">)</span> <span class="k">=</span> <span class="nv">d</span><span class="o">.</span><span class="py">toInt</span>
<span class="k">val</span> <span class="nv">x</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="mf">20.23</span>
<span class="c1">//Prints 20</span>
<span class="nf">println</span><span class="o">(</span><span class="n">x</span><span class="o">)</span></code></pre></figure>
<p>Very handy in situations where it needs this to be done by default</p>
<h3><b><a name="Decompiled" class="inter-header">Taking a look at the decompiled code</a></b></h3>
<p>The decompiled code for this is pretty simple.</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">public</span> <span class="kd">final</span> <span class="kt">void</span> <span class="n">delayedEndpoint$com$testing$Runnable</span><span class="err">$</span><span class="mi">1</span><span class="o">()</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span class="na">value</span> <span class="o">=</span> <span class="mi">10</span><span class="o">;</span>
<span class="k">this</span><span class="o">.</span><span class="na">anotherValue</span> <span class="o">=</span> <span class="mi">2</span><span class="o">;</span>
<span class="o">.</span><span class="na">MODULE</span><span class="err">$</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="nc">BoxesRunTime</span><span class="o">.</span><span class="na">boxToInteger</span><span class="o">(</span><span class="k">this</span><span class="o">.</span><span class="na">multiply</span><span class="o">(</span><span class="k">this</span><span class="o">.</span><span class="na">anotherValue</span><span class="o">())));</span>
<span class="o">}</span></code></pre></figure>
<p>It directly replaces the references to the variables at compile time. If it seems confusing, the first thing is to look in the <a href="https://docs.scala-lang.org/tour/implicit-parameters.html">docs</a> and take a look at the decompiled code.</p>
<h3><b><a name="Conclusion" class="inter-header">Conclusion</a></b></h3>
<p>Scala is not the first language to have this. C# has implicits which work very similar to Scala in terms of functionality and having a slightly different syntax. Scala libraries such as Akka make use implicits heavily. Many advanced patterns are possible with <code class="language-plaintext highlighter-rouge">implicits</code> which I’ll cover in later tutorials.</p>
<p>This design pattern tends to be over used and should be used with caution. With power comes responsibility.</p>Madusudanan.B.NImplicitsScala Articles Index2017-12-03T00:00:00+00:002017-12-03T00:00:00+00:00http://madusudanan.com/blog/scala-articles-index<h2 id="learning-scala">Learning Scala</h2>
<p>This will act as a reference to all of my Scala blog articles.</p>
<ul>
<li><a href="/blog/scala-tutorials-part-1-getting-started/">Part 1 - Getting Started</a>
<ul>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#Intro">Introduction to scala and environment setup</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#ScalaHelloWorld">First Hello World!!</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#Variables">Variables</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#ReferenceVsValue">Reference vs Value Immutability</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#AdvancedUnderstanding">Immutability under the hood</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#ValVsFinal">Comparing and Contrasting val and final</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#DataTypes">Data types in Scala</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#TypeInference">Type Inference</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#Initialize">Variable initialization</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#TypeAnnotations">Type annotations</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#TypeAscriptions">Type ascriptions</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#LazyVal">Lazy val</a></li>
<li><a href="/blog/scala-tutorials-part-1-getting-started/#Homework">Homework</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/">Part 2 - Type Inference & types in Scala</a>
<ul>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#Perspective">What exactly is type inference from a programmer’s perspective</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#TypeSystemOverview">Overview of a type system</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#TypeSystem">Language classification according to their type system</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#Hindley">Hindley-Milner(HM) type inference</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#LocalvsGlobal">Local vs Global type inference and sub-typing - Why scala choose local type inference</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#ScalaTypes">A brief overview of scala’s type system and subtyping</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#ValueVsReference">Value types and Reference types</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#Usage">When to use type inference?</a></li>
<li><a href="/blog/scala-tutorials-part-2-type-inference-in-scala/#References">References</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-3-methods/">Part 3 - Methods</a>
<ul>
<li><a href="/blog/scala-tutorials-part-3-methods/#Primer">Primer</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#Syntax">Syntax of Methods</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#Unit">The Unit type</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#MethodParameters">Immutable method parameters</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#Return">Note on the return keyword</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#Heterogeneous">Heterogeneous return types</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#CallByNamevsValue">Call by name vs Call by value</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#DefaultValues">Default values for method parameters</a></li>
<li><a href="/blog/scala-tutorials-part-3-methods/#Stubbing">Stubbing out methods</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-4-objects/">Part 4 - Objects in Scala</a>
<ul>
<li><a href="/blog/scala-tutorials-part-4-objects/#Intro">What are objects?</a></li>
<li><a href="/blog/scala-tutorials-part-4-objects/#Singleton">Concept of a singleton and comparison with object in scala</a></li>
<li><a href="/blog/scala-tutorials-part-4-objects/#Static">Static and OOP</a></li>
<li><a href="/blog/scala-tutorials-part-4-objects/#CompanionObj">Companion objects</a></li>
<li><a href="/blog/scala-tutorials-part-4-objects/#HelloWorldReVisit">Hello world revisited</a></li>
<li><a href="/blog/scala-tutorials-part-4-objects/#DeeperMain">Deeper understanding of main methods</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-5-classes/">Part 5 - Classes</a>
<ul>
<li><a href="/blog/scala-tutorials-part-5-classes/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#AccessVisibility">Access and visibility</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#Constructors">Constructors</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#FieldParams">Class parameters and Class fields</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#PromotingParams">Promoting class parameters</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#Direct">Direct member access</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#ImmutabilityAndMutability">Immutable objects and Mutable objects</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#WhenToUse">When to use Getters and Setters</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#ScalaStyleGetter">Scala style Getters and Setters</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#AuxiliaryConstructors">Auxiliary constructors</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#DefaultConstructorValues">Default constructor values</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#NamedArguments">Named arguments</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#AbsClasses">Abstract classes</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#Override">The Override keyword</a></li>
<li><a href="/blog/scala-tutorials-part-5-classes/#WhenToUseAbs">When to use abstract classes</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/">Part 6 - Case Classes</a>
<ul>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Declaration">Declaring case classes</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Consumption">Creating classes without the new keyword</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Access">Accessing variables</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Immutable">Immutable objects</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Equals">Structural equality - Automatic equals generation</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#ReferenceEquality">Reference equality</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#String">String representation</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Hashcode">Automatic hashcode generation</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Copy">Case class copy</a></li>
<li><a href="/blog/scala-tutorials-part-6-case-classes/#Decompiled">Case class decompiled</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/">Part 7 - Objects Everywhere</a>
<ul>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Introduction">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#DataTypes">Data types as Objects</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Operations">Operations on types</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Creation">Creation of custom types</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#LangVsAbs">Language constructs vs Library Abstractions</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Java">Java’s data type boxing/unboxing compared</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Bigint">Bigint example</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Typecasting">Typecasting</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Value">Value comparison</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#CodeBlocks">Code blocks as values</a></li>
<li><a href="/blog/scala-tutorials-part-7-objects-everywhere/#Compared">Implementations in other languages and some notes</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-8-traits/">Part 8 - Traits</a>
<ul>
<li><a href="/blog/scala-tutorials-part-8-traits/#Intro">Introduction to traits</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#TraitSyntax">A basic trait - Syntax explanation</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#JavaAbsVariables">Concept of abstract variables in java</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#TypeAnnotations">Type annotations for abstract variables</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#AbsConcrete">Mixing abstract and concrete members</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#JavaSyntaxDifference">Java syntax differences</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#ExtendingTraits">Extending traits</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#WithKeyword">The with keyword</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#Mixin">Mixin class composition</a></li>
<li><a href="/blog/scala-tutorials-part-8-traits/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/">Part 9 - Intro to Functional Programming in Scala</a>
<ul>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#Moores">Taking a look at moore’s law in 2017</a></li>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#ProgrammingParadigm">What is a programming paradigm?</a></li>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#VonNeumann">Understanding the von-neumann programming style</a></li>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#WrongVonNeumann">What’s wrong with von-neumann style</a></li>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#MapReduce">Map reduce & Immutability</a></li>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#PureFunctions">Pure functions in scala</a></li>
<li><a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#Abstractions">Higher level abstractions & avoiding conceptualizing programs word by word</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-10-case-objects-in-scala/">Part 10 - Case Objects</a>
<ul>
<li><a href="/blog/scala-tutorials-part-10-case-objects-in-scala/#Intro">Introduction</a></li>
<li><a href="/scala-tutorials-part-10-case-objects-in-scala/#ComparisonCOvsCC">Case objects vs Case classes</a></li>
<li><a href="/blog/scala-tutorials-part-10-case-objects-in-scala/#Advantages">Advantages of case objects</a></li>
<li><a href="/blog/scala-tutorials-part-10-case-objects-in-scala/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/">Part 11 - String Interpolation</a>
<ul>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/#Intro">String concatenation in java</a></li>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/#Comparison">Concatenation vs Interpolation</a></li>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/#Anatomy">Anatomy of a string interpolator in scala</a></li>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/#OpCombine">Combining operations with standard interpolation</a></li>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/#Format">Format interpolator</a></li>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/#Raw">Raw interpolator</a></li>
<li><a href="/blog/scala-tutorials-part-11-string-interpolation/#OtherLang">Interpolation in other languages</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-12-infix-notation/">Part 12 - Infix Notation</a>
<ul>
<li><a href="/blog/scala-tutorials-part-12-infix-notation/#DotNotation">Dot notation in java</a></li>
<li><a href="/blog/scala-tutorials-part-12-infix-notation/#InfixNotation">Infix notation introduction</a></li>
<li><a href="/blog/scala-tutorials-part-12-infix-notation/#Verbosity">Dealing with verbosity</a></li>
<li><a href="/blog/scala-tutorials-part-12-infix-notation/#Suffix">Avoiding infix in suffix notation methods</a></li>
<li><a href="/blog/scala-tutorials-part-12-infix-notation/#N-Arity">N-Arity methods</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-13-loops-in-scala/">Part 13 - Loops</a>
<ul>
<li><a href="/blog/scala-tutorials-part-13-loops-in-scala/#Concept">Concept of looping</a></li>
<li><a href="/blog/scala-tutorials-part-13-loops-in-scala/#BothIndexes">Controlling both indexes</a></li>
<li><a href="/blog/scala-tutorials-part-13-loops-in-scala/#StartingIndex">Controlling only the starting index</a></li>
<li><a href="/blog/scala-tutorials-part-13-loops-in-scala/#NoIndex">No Index for expressions</a></li>
<li><a href="/blog/scala-tutorials-part-13-loops-in-scala/#LoopGuards">For loop with guards</a></li>
<li><a href="/blog/scala-tutorials-part-13-loops-in-scala/#Yield">Yield construct</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-14-uniform-access-principle/">Part 14 - Uniform Access Principle</a>
<ul>
<li><a href="/blog/scala-tutorials-part-14-uniform-access-principle/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-14-uniform-access-principle/#UAPScala">Implementation in scala</a></li>
<li><a href="/blog/scala-tutorials-part-14-uniform-access-principle/#NameSpaceCol">Namespace Collision</a></li>
<li><a href="/blog/scala-tutorials-part-14-uniform-access-principle/#Conclusion">Summing it up</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-15-the-apply-method/">Part 15 - The Apply Method</a>
<ul>
<li><a href="/blog/scala-tutorials-part-15-the-apply-method/#Intro">The apply function</a></li>
<li><a href="/blog/scala-tutorials-part-15-the-apply-method/#ApplyInScala">Using apply in scala</a></li>
<li><a href="/blog/scala-tutorials-part-15-the-apply-method/#CaseClassApply">Apply in case classes</a></li>
<li><a href="/blog/scala-tutorials-part-15-the-apply-method/#WithoutNew">Creating objects without new keyword</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-16-the-option-type/">Part 16 - The Option Type</a>
<ul>
<li><a href="/blog/scala-tutorials-part-16-the-option-type/#FirstLineDefense">First line of defense in variables</a></li>
<li><a href="/blog/scala-tutorials-part-16-the-option-type/#Option">Introduction to the Option type</a></li>
<li><a href="/blog/scala-tutorials-part-16-the-option-type/#CustomOption">Creating our own Option type</a></li>
<li><a href="/blog/scala-tutorials-part-16-the-option-type/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-17-the-update-method/">Part 17 - The Update method</a>
<ul>
<li><a href="/blog/scala-tutorials-part-17-the-update-method/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-17-the-update-method/#ArrayExample">Example in scala arrays</a></li>
<li><a href="/blog/scala-tutorials-part-17-the-update-method/#CustomExample">Custom example</a></li>
<li><a href="/blog/scala-tutorials-part-17-the-update-method/#MultipleUpdates">Multiple update methods</a></li>
<li><a href="/blog/scala-tutorials-part-17-the-update-method/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-18-extractors/">Part 18 - Extractors</a>
<ul>
<li><a href="/blog/scala-tutorials-part-18-extractors/#Intro">What are extractors?</a></li>
<li><a href="/blog/scala-tutorials-part-18-extractors/#Staging">Setting the stage</a></li>
<li><a href="/blog/scala-tutorials-part-18-extractors/#Unapply">Implementing the unapply method logic</a></li>
<li><a href="/blog/scala-tutorials-part-18-extractors/#PatternMatch">Usage of extractors in pattern matching</a></li>
<li><a href="/blog/scala-tutorials-part-18-extractors/#MultipleParams">Extractors with multiple parameters</a></li>
<li><a href="/blog/scala-tutorials-part-18-extractors/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/">Part 19 - Lambda Calculus</a>
<ul>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#History">History</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#TuringCompleteness">The notion of turing completeness</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#ChurchTuring">Church-Turing thesis</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#CallByName">Revisiting call by name</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#Functions">Intro to Functions</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#FirstClass">Functions as first class citizens</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#FunctionsAsValues">Functions as values</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#AnonymousFunctions">Anonymous functions</a></li>
<li><a href="/blog/scala-tutorials-part-19-lambda-calculus/#WrapUp">Wrapping up</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-20-internals-of-functions-in-jvm/">Part 20 - Internals of Functions in the JVM</a>
<ul>
<li><a href="/blog/scala-tutorials-part-20-internals-of-functions-in-jvm/#Decompiling">Decompiling Functions</a></li>
<li><a href="/blog/scala-tutorials-part-20-internals-of-functions-in-jvm/#FunctionTrait">The FunctionN trait</a></li>
<li><a href="/blog/scala-tutorials-part-20-internals-of-functions-in-jvm/#FunctionsVsMethods">Functions vs Methods</a></li>
<li><a href="/blog/scala-tutorials-part-20-internals-of-functions-in-jvm/#Interoperability">Interoperability with OOP</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-21-referential-transparency/">Part 21 - Referential Transparency</a>
<ul>
<li><a href="/blog/scala-tutorials-part-21-referential-transparency/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-21-referential-transparency/#InAction">Referential transparency in action</a></li>
<li><a href="/blog/scala-tutorials-part-21-referential-transparency/#RealWorld">Referential transparency in the real world</a></li>
<li><a href="/blog/scala-tutorials-part-21-referential-transparency/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-22-substitution-model-in-scala/">Part 22 - Substitution model of evaluation</a>
<ul>
<li><a href="/blog/scala-tutorials-part-22-substitution-model-in-scala/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-22-substitution-model-in-scala/#ExpressionEvaluation">Expression evaluation</a></li>
<li><a href="/blog/scala-tutorials-part-22-substitution-model-in-scala/#FunctionEvaluation">Function evaluation</a></li>
<li><a href="/blog/scala-tutorials-part-22-substitution-model-in-scala/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/">Part 23 - Pattern matching in Scala</a>
<ul>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#PTValues">Pattern matching value types</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#Conditionals">Using conditionals</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#Strings">Pattern matching strings</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#CaptureValues">Capturing values</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#Options">Matching with Options</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#HeterogenousMatch">Heterogeneous pattern matching</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#DecomposingTypes">Decomposing types using pattern matching</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#CaseClass">Case class matching</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#PTDecompiled">Pattern matching decompiled</a></li>
<li><a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/#Finale">Finale</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-24-exception-handling/">Part 24 - Exception Handling</a>
<ul>
<li><a href="/blog/scala-tutorials-part-24-exception-handling/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-24-exception-handling/#CheckedExceptions">The case of Checked Exceptions</a></li>
<li><a href="/blog/scala-tutorials-part-24-exception-handling/#TryCatch">Handling exceptions with try-catch</a></li>
<li><a href="/blog/scala-tutorials-part-24-exception-handling/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-25-recursion/">Part 25 - Recursion </a>
<ul>
<li><a href="/blog/scala-tutorials-part-25-recursion/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-25-recursion/#StackOverflow">Stack overflow</a></li>
<li><a href="/blog/scala-tutorials-part-25-recursion/#TailRecursion">Tail recursion</a></li>
<li><a href="/blog/scala-tutorials-part-25-recursion/#TailRec">Tailrec annotation</a></li>
<li><a href="/blog/scala-tutorials-part-25-recursion/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-26-type-parameterization/">Part 26 - Type parameterization</a>
<ul>
<li><a href="/blog/scala-tutorials-part-26-type-parameterization/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-26-type-parameterization/#Example">Getting started with an example</a></li>
<li><a href="/blog/scala-tutorials-part-26-type-parameterization/#CustomClasses">Using custom class types</a></li>
<li><a href="/blog/scala-tutorials-part-26-type-parameterization/#MultiParameter">Multiple type parameters</a></li>
<li><a href="/blog/scala-tutorials-part-26-type-parameterization/#DecomposingTypes">Decomposing types with Generic methods</a></li>
<li><a href="/blog/scala-tutorials-part-26-type-parameterization/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-27-higher-order-functions/">Part 27 - Higher Order Functions</a>
<ul>
<li><a href="/blog/scala-tutorials-part-27-higher-order-functions/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-27-higher-order-functions/#Example">Example with collections</a></li>
<li><a href="/blog/scala-tutorials-part-27-higher-order-functions/#CustomHigherOrder">Creating a custom higher order function</a></li>
<li><a href="/blog/scala-tutorials-part-27-higher-order-functions/#Conclusion">Closing notes</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-28-getting-started-with-implicits/">Part 28 - Getting started with Implicits</a>
<ul>
<li><a href="/blog/scala-tutorials-part-28-getting-started-with-implicits/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-28-getting-started-with-implicits/#ImplicitParams">Implicit Method Parameters</a></li>
<li><a href="/blog/scala-tutorials-part-28-getting-started-with-implicits/#ImplicitFunctions">Implicit Functions</a></li>
<li><a href="/blog/scala-tutorials-part-28-getting-started-with-implicits/#Decompiled">Taking a look at the decompiled code</a></li>
<li><a href="/blog/scala-tutorials-part-28-getting-started-with-implicits/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-29-design-by-contract/">Part 29 - Design by Contract</a>
<ul>
<li><a href="/blog/scala-tutorials-part-29-design-by-contract/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-29-design-by-contract/#Overview">High Level Overview</a></li>
<li><a href="/blog/scala-tutorials-part-29-design-by-contract/#AssertAssume">Assert and Assume</a></li>
<li><a href="/blog/scala-tutorials-part-29-design-by-contract/#RequireEnsuring">Require and Ensuring</a></li>
<li><a href="/blog/scala-tutorials-part-29-design-by-contract/#Conclusion">Conclusion</a></li>
</ul>
</li>
<li><a href="/blog/scala-tutorials-part-30-closures/">Part 30 - Closures</a>
<ul>
<li><a href="/blog/scala-tutorials-part-30-closures/#Intro">Introduction</a></li>
<li><a href="/blog/scala-tutorials-part-30-closures/#StateBehaviour">Encapsulating state and behaviour</a></li>
<li><a href="/blog/scala-tutorials-part-30-closures/#FreeVariables">Free variables</a></li>
<li><a href="/blog/scala-tutorials-part-30-closures/#ReferentialTransparency">Reasoning about referential transparency</a></li>
</ul>
</li>
</ul>Madusudanan.B.NLearning ScalaScala Tutorials Part #27 - Higher Order Functions2017-11-10T00:00:00+00:002017-11-10T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-higher-order-functions<h2 id="higher-order-functions">Higher Order Functions</h2>
<p>This is part 27 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul fa-lg space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#Example">Example with collections</a></li>
<li><a href="#CustomHigherOrder">Creating a custom higher order function</a></li>
<li><a href="#Conclusion">Closing notes</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p>In <a href="/blog/scala-tutorials-part-19-lambda-calculus/">part 19</a>, we saw how functions are treated as first class citizens in Scala. In this article we are
going to take a look at higher order functions. <a href="https://en.wikipedia.org/wiki/Higher-order_function" target="_blank">Higher order functions</a>
are functions which are,</p>
<ul>
<li>Functions that takes another Function as a parameter</li>
<li>Functions that returns another Function</li>
</ul>
<h3><b><a name="Example" class="inter-header">Example with collections</a></b></h3>
<p>First we will define a <code class="language-plaintext highlighter-rouge">List</code> with some values.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">list</span> <span class="k">=</span> <span class="nc">List</span><span class="o">(</span><span class="mi">10</span><span class="o">,</span><span class="mi">11</span><span class="o">,</span><span class="mi">12</span><span class="o">,</span><span class="mi">13</span><span class="o">)</span></code></pre></figure>
<p>Next, lets define a function that doubles each value that is given to it.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nf">doubleValue</span> <span class="k">=</span> <span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=></span> <span class="n">x</span> <span class="o">*</span> <span class="n">x</span></code></pre></figure>
<p>The <code class="language-plaintext highlighter-rouge">List</code> class has something called a <code class="language-plaintext highlighter-rouge">map</code> function which takes in other function and produces a new <code class="language-plaintext highlighter-rouge">List</code>. We are going to feed our <code class="language-plaintext highlighter-rouge">doubleValue</code>
function to it.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">doubledList</span> <span class="k">=</span> <span class="nv">list</span><span class="o">.</span><span class="py">map</span><span class="o">(</span><span class="n">x</span> <span class="k">=></span> <span class="nf">doubleValue</span><span class="o">(</span><span class="n">x</span><span class="o">))</span></code></pre></figure>
<p>This gives us a list with values <code class="language-plaintext highlighter-rouge">(100, 121, 144, 169)</code>. The <code class="language-plaintext highlighter-rouge">map</code> function is a classic example of a higher order function. We can also give it an
anonymous function in case we do not want to define a function explicitly.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">doubledList</span> <span class="k">=</span> <span class="nv">list</span><span class="o">.</span><span class="py">map</span><span class="o">(</span><span class="n">x</span> <span class="k">=></span> <span class="n">x</span> <span class="o">*</span> <span class="n">x</span><span class="o">)</span></code></pre></figure>
<h3><b><a name="CustomHigherOrder" class="inter-header">Creating a custom higher order function</a></b></h3>
<p>In order to fully understand Higher Order functions, its best that we learn to create one ourselves. Let’s create a function that applies a pattern
to a given string.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="c1">//Function that decorates the given string with the given logic</span>
<span class="k">def</span> <span class="nf">HTMLStringDecorator</span><span class="o">(</span><span class="n">text</span><span class="k">:</span><span class="kt">String</span><span class="o">,</span><span class="n">f</span><span class="k">:</span><span class="kt">String</span> <span class="o">=></span> <span class="nc">String</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">f</span><span class="o">(</span><span class="n">text</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>This is an example of a function that takes another function as a parameter. <code class="language-plaintext highlighter-rouge">f</code> is a variable which is of type function and one which takes in a
String and gives out another <code class="language-plaintext highlighter-rouge">String</code>. Next, we will create a function which given a string appends a <code class="language-plaintext highlighter-rouge"><title></code> tag to it and which can be passed
into the <code class="language-plaintext highlighter-rouge">HTMLStringDecorator</code> function.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="c1">//Function that appends the title tag</span>
<span class="k">def</span> <span class="nf">titleTag</span><span class="o">(</span><span class="n">data</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=></span> <span class="nc">String</span> <span class="k">=</span> <span class="o">{</span>
<span class="k">_</span> <span class="k">:</span> <span class="kt">String</span> <span class="o">=></span> <span class="n">s</span><span class="s">"<title>$data</title>"</span>
<span class="o">}</span></code></pre></figure>
<p>Unlike <code class="language-plaintext highlighter-rouge">HTMLStringDecorator</code> this returns a function itself. We can then call the decorator with the title tag appender function.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">message</span> <span class="k">=</span> <span class="s">"hello"</span>
<span class="nf">println</span><span class="o">(</span>
<span class="nc">HTMLStringDecorator</span><span class="o">(</span>
<span class="n">message</span><span class="o">,</span>
<span class="nf">titleTag</span><span class="o">(</span><span class="n">message</span><span class="o">)</span>
<span class="o">)</span>
<span class="o">)</span>
<span class="c1">//Prints</span>
<span class="c1">//<title>hello</title></span></code></pre></figure>
<p>This might seem simple, but using such patterns we can build powerful DSL based syntax and languages. Higher order functions are just one piece of the
puzzle, we still have partially applied functions, closures, currying etc., which can help build systems that make complex patterns much simpler to
work with.</p>
<h3><b><a name="Conclusion" class="inter-header">Closing notes</a></b></h3>
<p>We saw a very basic overview of higher order functions. At this point this knowledge should be enough to move forward. But we must remember that with
such power comes responsibility and not everything must be dealt with a DSL/Higher order functions. Design and best practices is a completely
different area which we will explore in later tutorials.</p>Madusudanan.B.NHigher Order FunctionsScala Tutorials Part #26 - Type parameterization2017-11-05T00:00:00+00:002017-11-05T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-generics-and-parameterized-types<h2 id="type-parameterization">Type parameterization</h2>
<p>This is part 26 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul fa-lg space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#Example">Getting started with an example</a></li>
<li><a href="#CustomClasses">Using custom class types</a></li>
<li><a href="#MultiParameter">Multiple type parameters</a></li>
<li><a href="#DecomposingTypes">Decomposing types with Generic methods</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p>Type parameterization or otherwise called as generics combined with Scala’s type system add stability to the code. This concept is not
new to Scala. Java added support for generics in J2SE 5.0 which was released in 2004. It equips the programmer with the ability to write
code which is more predictable during compile time rather than time. It is heavily used in the collections API of Java and Scala.</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="nc">ArrayList</span><span class="o"><</span><span class="nc">String</span><span class="o">></span> <span class="n">list</span><span class="o">=</span><span class="k">new</span> <span class="nc">ArrayList</span><span class="o"><</span><span class="nc">String</span><span class="o">>();</span>
<span class="n">list</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="s">"1"</span><span class="o">);</span>
<span class="n">list</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="s">"2"</span><span class="o">);</span></code></pre></figure>
<p>Any type within the Java language type system can be encoded within the <code class="language-plaintext highlighter-rouge"><></code>. These are called generics and the class is just defined once using
the generics container and can be re-used.</p>
<p>Generics originally came from the world of Functional Programming.</p>
<h3><b><a name="Example" class="inter-header">Getting started with an example</a></b></h3>
<p>We are going to design a Stack data structure from scratch. This is just an example and you would typically use something within collections when
it come to actual production code. But for explanation purposes, they do just fine.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">class</span> <span class="nc">Stack</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="o">{</span>
<span class="o">}</span></code></pre></figure>
<p>Here <code class="language-plaintext highlighter-rouge">A</code> is a type parameter similar to <code class="language-plaintext highlighter-rouge">E</code> used in Java collections API.</p>
<p>Next we will declare two variables which are private to the class.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="c1">//Internal array buffer. Kind of like java array list</span>
<span class="k">private</span> <span class="k">val</span> <span class="nv">arrayBuffer</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">ArrayBuffer</span><span class="o">[</span><span class="kt">A</span><span class="o">]()</span>
<span class="c1">//Stack position pointer</span>
<span class="k">private</span> <span class="k">var</span> <span class="n">stack_pointer</span> <span class="k">=</span> <span class="o">-</span><span class="mi">1</span>
</code></pre></figure>
<p>We will implement three basic methods <code class="language-plaintext highlighter-rouge">push</code>, <code class="language-plaintext highlighter-rouge">pop</code> and <code class="language-plaintext highlighter-rouge">peek</code>.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">def</span> <span class="nf">push</span><span class="o">(</span><span class="n">a</span><span class="k">:</span><span class="kt">A</span><span class="o">)</span><span class="k">:</span> <span class="kt">Unit</span> <span class="o">=</span> <span class="o">{</span>
<span class="n">stack_pointer</span> <span class="k">=</span> <span class="n">stack_pointer</span> <span class="o">+</span> <span class="mi">1</span>
<span class="nv">arrayBuffer</span><span class="o">.</span><span class="py">append</span><span class="o">(</span><span class="n">a</span><span class="o">)</span>
<span class="o">}</span>
<span class="k">def</span> <span class="nf">pop</span><span class="o">()</span> <span class="k">:</span> <span class="kt">Option</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
<span class="nf">if</span><span class="o">(</span><span class="n">stack_pointer</span> <span class="o">==</span> <span class="o">-</span><span class="mi">1</span><span class="o">){</span>
<span class="nc">None</span>
<span class="o">}</span>
<span class="k">else</span><span class="o">{</span>
<span class="k">val</span> <span class="nv">poppedElement</span> <span class="k">=</span> <span class="nf">arrayBuffer</span><span class="o">(</span><span class="n">stack_pointer</span><span class="o">)</span>
<span class="n">stack_pointer</span> <span class="k">=</span> <span class="n">stack_pointer</span> <span class="o">-</span> <span class="mi">1</span>
<span class="nc">Some</span><span class="o">(</span><span class="n">poppedElement</span><span class="o">)</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="k">def</span> <span class="nf">peek</span><span class="o">()</span> <span class="k">:</span> <span class="kt">Option</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
<span class="nf">if</span><span class="o">(</span><span class="n">stack_pointer</span> <span class="o">!=</span> <span class="o">-</span><span class="mi">1</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Some</span><span class="o">(</span><span class="nf">arrayBuffer</span><span class="o">(</span><span class="n">stack_pointer</span><span class="o">))</span>
<span class="o">}</span>
<span class="k">else</span> <span class="o">{</span>
<span class="nc">None</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<p>Our final implementation now looks like this.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">class</span> <span class="nc">Stack</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="o">{</span>
<span class="c1">//Internal array buffer. Kind of like java array list</span>
<span class="k">private</span> <span class="k">val</span> <span class="nv">arrayBuffer</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">ArrayBuffer</span><span class="o">[</span><span class="kt">A</span><span class="o">]()</span>
<span class="c1">//Pointer</span>
<span class="k">private</span> <span class="k">var</span> <span class="n">stack_pointer</span> <span class="k">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="k">def</span> <span class="nf">push</span><span class="o">(</span><span class="n">a</span><span class="k">:</span><span class="kt">A</span><span class="o">)</span><span class="k">:</span> <span class="kt">Unit</span> <span class="o">=</span> <span class="o">{</span>
<span class="n">stack_pointer</span> <span class="k">=</span> <span class="n">stack_pointer</span> <span class="o">+</span> <span class="mi">1</span>
<span class="nv">arrayBuffer</span><span class="o">.</span><span class="py">append</span><span class="o">(</span><span class="n">a</span><span class="o">)</span>
<span class="o">}</span>
<span class="k">def</span> <span class="nf">pop</span><span class="o">()</span> <span class="k">:</span> <span class="kt">Option</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
<span class="nf">if</span><span class="o">(</span><span class="n">stack_pointer</span> <span class="o">==</span> <span class="o">-</span><span class="mi">1</span><span class="o">){</span>
<span class="nc">None</span>
<span class="o">}</span>
<span class="k">else</span><span class="o">{</span>
<span class="k">val</span> <span class="nv">poppedElement</span> <span class="k">=</span> <span class="nf">arrayBuffer</span><span class="o">(</span><span class="n">stack_pointer</span><span class="o">)</span>
<span class="n">stack_pointer</span> <span class="k">=</span> <span class="n">stack_pointer</span> <span class="o">-</span> <span class="mi">1</span>
<span class="nc">Some</span><span class="o">(</span><span class="n">poppedElement</span><span class="o">)</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="k">def</span> <span class="nf">peek</span><span class="o">()</span> <span class="k">:</span> <span class="kt">Option</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
<span class="nf">if</span><span class="o">(</span><span class="n">stack_pointer</span> <span class="o">!=</span> <span class="o">-</span><span class="mi">1</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Some</span><span class="o">(</span><span class="nf">arrayBuffer</span><span class="o">(</span><span class="n">stack_pointer</span><span class="o">))</span>
<span class="o">}</span>
<span class="k">else</span> <span class="o">{</span>
<span class="nc">None</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></figure>
<p>Using this data structure is pretty simple.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">stack</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Stack</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span>
<span class="nv">stack</span><span class="o">.</span><span class="py">push</span><span class="o">(</span><span class="mi">10</span><span class="o">)</span>
<span class="nv">stack</span><span class="o">.</span><span class="py">push</span><span class="o">(</span><span class="mi">20</span><span class="o">)</span>
<span class="nv">stack</span><span class="o">.</span><span class="py">push</span><span class="o">(</span><span class="mi">30</span><span class="o">)</span>
<span class="nf">println</span><span class="o">(</span><span class="nv">stack</span><span class="o">.</span><span class="py">pop</span><span class="o">())</span>
<span class="nf">println</span><span class="o">(</span><span class="nv">stack</span><span class="o">.</span><span class="py">peek</span><span class="o">())</span>
</code></pre></figure>
<h3><b><a name="CustomClasses" class="inter-header">Using custom class types</a></b></h3>
<p>Since the type <code class="language-plaintext highlighter-rouge">A</code> can be used to encode almost any type, lets try some of our custom classes.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="c1">//Root trait</span>
<span class="k">trait</span> <span class="nc">Car</span>
<span class="c1">//Types extending from the Car trait</span>
<span class="k">class</span> <span class="nc">Toyota</span> <span class="k">extends</span> <span class="nc">Car</span>
<span class="k">class</span> <span class="nc">Hyundai</span> <span class="k">extends</span> <span class="nc">Car</span> </code></pre></figure>
<p>We can then use these classes in our stack data structure.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">t</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Toyota</span>
<span class="k">val</span> <span class="nv">h</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Hyundai</span>
<span class="k">val</span> <span class="nv">stack</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Stack</span><span class="o">[</span><span class="kt">Car</span><span class="o">]</span>
<span class="nv">stack</span><span class="o">.</span><span class="py">push</span><span class="o">(</span><span class="n">t</span><span class="o">)</span>
<span class="nv">stack</span><span class="o">.</span><span class="py">push</span><span class="o">(</span><span class="n">h</span><span class="o">)</span></code></pre></figure>
<h3><b><a name="MultiParameter" class="inter-header">Multiple type parameters</a></b></h3>
<p>The Java language has an interface called <a href="https://docs.oracle.com/javase/tutorial/java/generics/types.html" target="_blank"><code class="language-plaintext highlighter-rouge">Pair</code></a> which goes as
follows,</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">public</span> <span class="kd">interface</span> <span class="nc">Pair</span><span class="o"><</span><span class="no">K</span><span class="o">,</span> <span class="no">V</span><span class="o">></span> <span class="o">{</span>
<span class="kd">public</span> <span class="no">K</span> <span class="nf">getKey</span><span class="o">();</span>
<span class="kd">public</span> <span class="no">V</span> <span class="nf">getValue</span><span class="o">();</span>
<span class="o">}</span></code></pre></figure>
<p>It has two generic parameters. This is used in collections such as <code class="language-plaintext highlighter-rouge">HashMap</code>. Scala’s counterpart is not that different.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">trait</span> <span class="nc">Pair</span><span class="o">[</span><span class="kt">A</span>,<span class="kt">B</span><span class="o">]</span> <span class="o">{</span>
<span class="k">def</span> <span class="nf">getKey</span> <span class="k">:</span> <span class="kt">A</span>
<span class="k">def</span> <span class="nf">getValue</span> <span class="k">:</span> <span class="kt">B</span>
<span class="o">}</span></code></pre></figure>
<p>The <code class="language-plaintext highlighter-rouge">[]</code> is equivalent to <code class="language-plaintext highlighter-rouge"><></code> in terms of syntactic sugar as we saw in examples above.</p>
<h3><b><a name="DecomposingTypes" class="inter-header">Decomposing types with Generic methods</a></b></h3>
<p>In <a href="/blog/scala-tutorials-part-23-pattern-matching-in-scala/">part 23</a> we saw an example in which we decomposed a higher type <code class="language-plaintext highlighter-rouge">Any</code> into its sub types.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">typeTest</span> <span class="k">:</span> <span class="kt">Any</span> <span class="o">=</span> <span class="s">"String"</span>
<span class="n">typeTest</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">i</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Integer type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">d</span> <span class="k">:</span> <span class="kt">Double</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Double type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">f</span> <span class="k">:</span> <span class="kt">Float</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Float type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">s</span> <span class="k">:</span> <span class="kt">String</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"String type"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">:</span> <span class="kt">BigDecimal</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Big decimal type"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Unknown type"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>We explicitly gave the type ascription to the variable <code class="language-plaintext highlighter-rouge">typeTest</code>. This gets translated to type casting and it is not necessarily a good way to do this.</p>
<p>A better and a type safe way to accomplish this is by using a generic type signature. Let’s create an empty method which operates on generic types.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nf">identifyType</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">value</span><span class="k">:</span><span class="kt">A</span><span class="o">)</span> <span class="k">=</span> <span class="o">{</span>
<span class="o">}</span></code></pre></figure>
<p>The <code class="language-plaintext highlighter-rouge">[A]</code> after the method name is necessary to indicate that the method operates on generic types. Next we will do the same pattern matching inside
the method.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">def</span> <span class="nf">identifyType</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">value</span><span class="k">:</span><span class="kt">A</span><span class="o">)</span> <span class="k">=</span> <span class="o">{</span>
<span class="n">value</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">i</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Integer type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">d</span> <span class="k">:</span> <span class="kt">Double</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Double type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">f</span> <span class="k">:</span> <span class="kt">Float</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Float type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">s</span> <span class="k">:</span> <span class="kt">String</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"String type"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">:</span> <span class="kt">BigDecimal</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Big decimal type"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Unknown type"</span><span class="o">)</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<p>Now we can call this without explicit type annotation, since it is taken care by the compiler.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="c1">//String</span>
<span class="nf">identifyType</span><span class="o">(</span><span class="s">"Testing"</span><span class="o">)</span>
<span class="c1">//Integer</span>
<span class="nf">identifyType</span><span class="o">(</span><span class="mi">10</span><span class="o">)</span>
<span class="c1">//Double</span>
<span class="nf">identifyType</span><span class="o">(</span><span class="mf">20.0</span><span class="o">)</span>
<span class="k">case</span> <span class="k">class</span> <span class="nc">Box</span><span class="o">(</span><span class="n">name</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span>
<span class="k">val</span> <span class="nv">box</span> <span class="k">=</span> <span class="nc">Box</span><span class="o">(</span><span class="s">"test"</span><span class="o">)</span>
<span class="c1">//Custom type - No explicit annotation</span>
<span class="nf">identifyType</span><span class="o">(</span><span class="n">box</span><span class="o">)</span></code></pre></figure>
<p>Prints out the following.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nc">String</span> <span class="k">type</span>
<span class="kt">Integer</span> <span class="k">type</span>
<span class="kt">Double</span> <span class="k">type</span>
<span class="kt">Unknown</span> <span class="k">type</span></code></pre></figure>
<h3><b><a name="Conclusion" class="inter-header">Conclusion</a></b></h3>
<p>Generics are a powerful way of abstraction and writing type safe code which is more compile time reliant rather than run time. We have merely scratched
the surface of what is possible with them in Scala and this article has been more like an introduction to its syntax. I have deliberately left out
advanced topics such as type variance, structural typing(duck typing) which will be explained in later tutorials.</p>
<p>The <code class="language-plaintext highlighter-rouge">Stack</code> data structure above is partially derived from the Scala lang’s official documentation guide on
<a href="https://docs.scala-lang.org/tour/generic-classes.html" target="_blank">generics</a>.</p>Madusudanan.B.NType parameterizationScala Tutorials Part #25 - Recursion2017-10-15T00:00:00+00:002017-10-15T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-recursion<h2 id="recursion">Recursion</h2>
<p><a href="https://en.wikipedia.org/wiki/Recursion_(computer_science)" target="_blank">Recursion</a> is a fundamental concept in many programming languages and it
is important to understand how it works in Scala and its significance in the language.</p>
<p>This is part 25 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#StackOverflow">Stack overflow</a></li>
<li><a href="#TailRecursion">Tail recursion</a></li>
<li><a href="#TailRec">Tailrec annotation</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p><img src="https://imgs.xkcd.com/comics/tabletop_roleplaying.png" alt="Recursion" /></p>
<p>Scala has full support for functional programming and recursion is important to write functional code.</p>
<p>Let’s take a simple factorial example.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">def</span> <span class="nf">factorial</span><span class="o">(</span><span class="n">x</span><span class="k">:</span><span class="kt">Int</span><span class="o">)</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">if</span><span class="o">(</span><span class="n">x</span><span class="o">==</span><span class="mi">0</span><span class="o">)</span> <span class="mi">1</span> <span class="k">else</span> <span class="n">x</span> <span class="o">*</span> <span class="nf">factorial</span><span class="o">(</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="o">)</span>
<span class="o">}</span>
</code></pre></figure>
<p>This piece of code is not tail-recursive, i.e the last part of the function creates additional stack frames per call. The moment you get pretty deep
in the call stack then you end up the famous <code class="language-plaintext highlighter-rouge">StackOverflowError</code></p>
<h3><b><a name="StackOverflow" class="inter-header">Stack overflow</a></b></h3>
<p>Let’s modify the above code to work on <code class="language-plaintext highlighter-rouge">BigInt</code> instead of <code class="language-plaintext highlighter-rouge">Int</code> so that we can simulate the error.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">def</span> <span class="nf">factorial</span><span class="o">(</span><span class="n">x</span><span class="k">:</span><span class="kt">BigInt</span><span class="o">)</span> <span class="k">:</span> <span class="kt">BigInt</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">if</span><span class="o">(</span><span class="n">x</span><span class="o">==</span><span class="mi">0</span><span class="o">)</span> <span class="mi">1</span> <span class="k">else</span> <span class="n">x</span> <span class="o">*</span> <span class="nf">factorial</span><span class="o">(</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>If we call this with a ridiculously high value such as <code class="language-plaintext highlighter-rouge">factorial(10000)</code> then,</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="nc">Exception</span> <span class="n">in</span> <span class="n">thread</span> <span class="s">"main"</span> <span class="n">java</span><span class="o">.</span><span class="na">lang</span><span class="o">.</span><span class="na">StackOverflowError</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">math</span><span class="o">.</span><span class="na">BigInt</span><span class="err">$</span><span class="o">.</span><span class="na">apply</span><span class="o">(</span><span class="nc">BigInt</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">49</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">math</span><span class="o">.</span><span class="na">BigInt</span><span class="err">$</span><span class="o">.</span><span class="na">long2bigInt</span><span class="o">(</span><span class="nc">BigInt</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">101</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">math</span><span class="o">.</span><span class="na">BigInt</span><span class="o">.</span><span class="na">isValidLong</span><span class="o">(</span><span class="nc">BigInt</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">131</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">math</span><span class="o">.</span><span class="na">BigInt</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="nc">BigInt</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">125</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">runtime</span><span class="o">.</span><span class="na">BoxesRunTime</span><span class="o">.</span><span class="na">equalsNumNum</span><span class="o">(</span><span class="nc">BoxesRunTime</span><span class="o">.</span><span class="na">java</span><span class="o">:</span><span class="mi">168</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">runtime</span><span class="o">.</span><span class="na">BoxesRunTime</span><span class="o">.</span><span class="na">equalsNumObject</span><span class="o">(</span><span class="nc">BoxesRunTime</span><span class="o">.</span><span class="na">java</span><span class="o">:</span><span class="mi">140</span><span class="o">)</span></code></pre></figure>
<p>The <code class="language-plaintext highlighter-rouge">Stack</code> space is a limited memory area, and this exception is unrecoverable and generally results in the application crashing. There
are plenty of resources on the web that goes into detail on explaining of how stack overflow occurs internally, so I am not going to bother
explaining.</p>
<h3><b><a name="TailRecursion" class="inter-header">Tail recursion</a></b></h3>
<p><img src="https://imgs.xkcd.com/comics/functional.png" alt="Xkcd Functional" /></p>
<p>The common way to overcome a stack overflow error is to write a tail recursive version. Developers will usually resort to loop constructs but its better
modeled with recursion when you are writing <a href="/blog/scala-tutorials-part-9-intro-to-functional-programming/#PureFunctions">pure functions</a>
which is <a href="/blog/scala-tutorials-part-21-referential-transparency/">referentially transparent</a>.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">def</span> <span class="nf">factorial</span><span class="o">(</span><span class="n">x</span><span class="k">:</span><span class="kt">BigInt</span><span class="o">)</span> <span class="k">:</span> <span class="kt">BigInt</span> <span class="o">=</span> <span class="o">{</span>
<span class="k">def</span> <span class="nf">internal</span> <span class="o">(</span><span class="n">acc</span><span class="k">:</span><span class="kt">BigInt</span><span class="o">,</span><span class="n">n</span><span class="k">:</span><span class="kt">BigInt</span><span class="o">)</span> <span class="k">:</span> <span class="kt">BigInt</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">if</span> <span class="o">(</span><span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="o">)</span> <span class="n">acc</span>
<span class="k">else</span> <span class="nf">internal</span><span class="o">(</span><span class="n">acc</span> <span class="o">*</span> <span class="n">n</span><span class="o">,</span> <span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="o">)</span>
<span class="o">}</span>
<span class="nf">internal</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="n">x</span><span class="o">)</span>
<span class="o">}</span>
</code></pre></figure>
<p>This version should run the <code class="language-plaintext highlighter-rouge">factorial(10000)</code> without any issue. In fact, it can run even higher numbers until we hit either a type limit or memory
issue. We create another internal helper function which acts as an accumulator which uses <code class="language-plaintext highlighter-rouge">n-1</code> as the last call which is tail recursive. Tail
recursion is the functional counterpart of iteration and hence it is always necessary to do tail call optimization when the values could get large.</p>
<p>Intellij is always helpful in telling us whether the function is tail recursive or not.</p>
<p><img src="/images/recursive.png" alt="Recursive" /></p>
<p><img src="/images/tail_recursive.png" alt="Tail recursive" /></p>
<p>I am not going to explain on converting regular functions into its tail recursive versions, that is a topic for another tutorial.</p>
<h3><b><a name="TailRec" class="inter-header">Tailrec annotation</a></b></h3>
<p>Apart from the IDE helping you out, the Scala compiler has an annotation that throws an error if the function is not tail recursive.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nd">@tailrec</span>
<span class="k">def</span> <span class="nf">factorial</span><span class="o">(</span><span class="n">x</span><span class="k">:</span><span class="kt">BigInt</span><span class="o">)</span> <span class="k">:</span> <span class="kt">BigInt</span> <span class="o">=</span> <span class="o">{</span>
<span class="nf">if</span><span class="o">(</span><span class="n">x</span><span class="o">==</span><span class="mi">0</span><span class="o">)</span> <span class="mi">1</span> <span class="k">else</span> <span class="n">x</span> <span class="o">*</span> <span class="nf">factorial</span><span class="o">(</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>Error is thrown at compile time.</p>
<p><img src="/images/tailrec_error.png" alt="Tail rec error" /></p>
<p>In this case, the compiler is not able to optimize into a loop. The annotation works as intended on the inner recursive function.</p>
<p><img src="/images/tailrec_success.png" alt="Tail rec success" /></p>
<p>It is important to understand what the <code class="language-plaintext highlighter-rouge">@tailrec</code> annotation actually means. Some important notes below.</p>
<ul>
<li>This annotation does not perform automatic optimization of recursive methods into a tail recursive one.</li>
<li>It is a common misunderstanding that the absence of this annotation will not optimize the method. JVM does an insane amount of code optimization and
it does not relate to this annotation being present. After the code passes the Scala compiler, it is all byte code. So the JVM does certain things
regardless of the language that it compile from.</li>
<li>Functions and methods are different as saw in many previous articles and this annotation only applies to methods and it does not work with functions.</li>
</ul>
<blockquote>
<p><a href="https://stackoverflow.com/a/35013414" target="_blank">You don’t annotate methods that can be optimized. You annotate methods that must be optimized, so that you will get a compile error, when they can’t be optimized.</a></p>
</blockquote>
<p>It is more of a documentation to the developers. Many functional languages such as Haskell perform automatic tail call optimization
(with conditions applied). Scala cannot do this due to the limitation with the JVM.</p>
<h3><b><a name="Conclusion" class="inter-header">Conclusion</a></b></h3>
<p>Recursion is interesting because it is very important for functional programming languages to write good functional code. There are some limitations
in the JVM due to which there is no automatic tail call optimization. But the <code class="language-plaintext highlighter-rouge">@tailrec</code> annotation comes in handy in such situations. Certain algorithms
such as tree traversals, search are naturally recursive in nature.</p>
<p>Hopefully this article gave you a good overview of recursion. They are not meant for replacing loops entirely, but with modern JVMs they should
work similar to loops in terms of performance. It is important to consult the documentation for your VM and also don’t forget to test everything.</p>Madusudanan.B.NRecursionScala Tutorials Part #24 - Exception Handling2017-10-09T00:00:00+00:002017-10-09T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-exception-handling<h2 id="exception-handling">Exception Handling</h2>
<p>This is part 24 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul fa-lg space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#CheckedExceptions">The case of Checked Exceptions</a></li>
<li><a href="#TryCatch">Handling exceptions with try-catch</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p>Exceptions occur when normal flow of execution gets disrupted. It is usually handled in a try-catch block with an optional finally block. They are
created from the root class <code class="language-plaintext highlighter-rouge">Exception</code> and an instance of the <code class="language-plaintext highlighter-rouge">Throwable</code> class is used to throw exception messages.</p>
<p>Below is a visual representation of how the class hierarchy is designed in the JVM.</p>
<p><img src="/images/exceptions.png" alt="Exception hierarchy" /></p>
<p>And then it branches into checked exceptions which needs to be handled by the caller, ones such as <code class="language-plaintext highlighter-rouge">FileNotFoundException</code>,
<code class="language-plaintext highlighter-rouge">OperationNotSupportedException</code> etc., and unchecked exceptions such as <code class="language-plaintext highlighter-rouge">OutOfMemoryException</code>, <code class="language-plaintext highlighter-rouge">NullPointerException</code> etc., It is a common
confusion that checked exceptions are compile time and unchecked exceptions happen at run time. The truth is that there is no such thing as compile time
exception and everything happens at run time. The difference between both is how they are handled. Checked exceptions are forced by the compiler
to be handled during compile time/build time while unchecked exceptions aren’t.</p>
<p><img src="/images/file_checked_exception.png" alt="Checked exception" /></p>
<p>Scala handles exceptions in a slightly different manner and for a good reason.</p>
<h3><b><a name="CheckedExceptions" class="inter-header">The case of Checked Exceptions</a></b></h3>
<p>Scala does not have checked exceptions. The compiler does not enforce exceptions to be handled. For example, the below code which is a direct translation
of the above java code block compiles just fine.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="nf">readFile</span><span class="o">(</span><span class="s">"somefile.txt"</span><span class="o">)</span>
<span class="k">def</span> <span class="nf">readFile</span><span class="o">(</span><span class="n">path</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span> <span class="k">=</span> <span class="o">{</span>
<span class="k">val</span> <span class="nv">file</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">File</span><span class="o">(</span><span class="n">path</span><span class="o">)</span>
<span class="k">val</span> <span class="nv">fileInputStream</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">FileInputStream</span><span class="o">(</span><span class="n">file</span><span class="o">)</span>
<span class="nf">println</span><span class="o">(</span><span class="nv">fileInputStream</span><span class="o">.</span><span class="py">read</span><span class="o">())</span>
<span class="o">}</span> </code></pre></figure>
<p>It will throw an error if there is no such file is present only at the run time. Checked exceptions have always been a topic of controversy.
<a href="https://testing.googleblog.com/2009/09/checked-exceptions-i-love-you-but-you.html" target="_blank">Here</a> is a good article on why checked exceptions are bad. This feature is at least controversial if not bad and hence the language developers decided to drop this.</p>
<h3><b><a name="TryCatch" class="inter-header">Handling exceptions with try-catch</a></b></h3>
<p>Like java, Scala has try/catch to handle exceptions. Let’s take a look at the same file read example.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nf">readFile</span><span class="o">(</span><span class="s">"somefile.txt"</span><span class="o">)</span>
<span class="k">def</span> <span class="nf">readFile</span><span class="o">(</span><span class="n">path</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span> <span class="k">=</span> <span class="o">{</span>
<span class="k">try</span> <span class="o">{</span>
<span class="k">val</span> <span class="nv">file</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">File</span><span class="o">(</span><span class="n">path</span><span class="o">)</span>
<span class="k">val</span> <span class="nv">fileInputStream</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">FileInputStream</span><span class="o">(</span><span class="n">file</span><span class="o">)</span>
<span class="nf">println</span><span class="o">(</span><span class="nv">fileInputStream</span><span class="o">.</span><span class="py">read</span><span class="o">())</span>
<span class="o">}</span>
<span class="k">catch</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">f</span> <span class="k">:</span> <span class="kt">FileNotFoundException</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"File not found"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">e</span> <span class="k">:</span> <span class="kt">IndexOutOfBoundsException</span> <span class="o">=></span> <span class="nv">e</span><span class="o">.</span><span class="py">printStackTrace</span><span class="o">()</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">:</span> <span class="kt">Throwable</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Unknown exception"</span><span class="o">)</span>
<span class="o">}</span>
<span class="k">finally</span> <span class="o">{</span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Inside finally block"</span><span class="o">)</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<p><code class="language-plaintext highlighter-rouge">try</code> is similar to Java which contains code that could cause an Exception. The <code class="language-plaintext highlighter-rouge">catch</code> block however is different and it uses pattern matching.
The <code class="language-plaintext highlighter-rouge">_</code> operator here is used as a wildcard operator which matches other than the ones above it. Everything else should be similar to its Java counterpart including the
<code class="language-plaintext highlighter-rouge">finally</code> block.</p>
<h3><b><a name="Conclusion" class="inter-header">Conclusion</a></b></h3>
<p>What we have explored in this article is just a beginning. Scala being a multi-paradigm language has many ways to deal with scenarios that could
cause errors. We already saw some of those in part 1 where we cannot leave a variable <a href="/blog/scala-tutorials-part-1-getting-started/#Initialize">uninitialized</a>
preventing null pointer to a certain degree and also the <a href="/blog/scala-tutorials-part-16-the-option-type/">Option/Some/None pattern</a> to deal with
undecidable situations.</p>
<p>General best practices such as giving descriptive error messages, not to catch <code class="language-plaintext highlighter-rouge">Error</code>, not to ignore exceptions etc., still apply.</p>Madusudanan.B.NException HandlingScala Tutorials Part #23 - Pattern Matching in Scala2017-10-05T00:00:00+00:002017-10-05T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-pattern-matching<h2 id="pattern-matching">Pattern Matching</h2>
<p>This is part 23 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p><i class="fa fa-list-ul fa-lg space-right"></i> Index</p>
<ul>
<li><a href="#PTValues">Pattern matching value types</a></li>
<li><a href="#Conditionals">Using conditionals</a></li>
<li><a href="#Strings">Pattern matching strings</a></li>
<li><a href="#CaptureValues">Capturing values</a></li>
<li><a href="#Options">Matching with Options</a></li>
<li><a href="#HeterogenousMatch">Heterogeneous pattern matching</a></li>
<li><a href="#DecomposingTypes">Decomposing types using pattern matching</a></li>
<li><a href="#CaseClass">Case class matching</a></li>
<li><a href="#PTDecompiled">Pattern matching decompiled</a></li>
<li><a href="#Finale">Finale</a></li>
</ul>
<h3><b><a name="PTValues" class="inter-header">Pattern matching value types</a></b></h3>
<p>We saw how <a href="/blog/scala-tutorials-part-18-extractors/">extractors</a> can aid pattern matching by writing an <code class="language-plaintext highlighter-rouge">unapply</code> method. In this article,
we are going to see how they actually work and also look at the internals.</p>
<p>Let’s say we have an Integer variable and want to do a match on it.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">status</span> <span class="k">=</span> <span class="mi">0</span>
<span class="n">status</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="mi">0</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"The status is false"</span><span class="o">)</span>
<span class="k">case</span> <span class="mi">1</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"The status is true"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Unknown status"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>Code is pretty self explanatory, it checks for matching values 0/1 and prints appropriate messages. The <code class="language-plaintext highlighter-rouge">_</code> is used to match any other value,
kind of like the <code class="language-plaintext highlighter-rouge">default</code> in java switch statements.</p>
<p>That was straightforward, let’s try with a double.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">score</span> <span class="k">=</span> <span class="mf">4.0</span>
<span class="n">score</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="mf">4.0</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"High score"</span><span class="o">)</span>
<span class="k">case</span> <span class="mf">3.0</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Moderate"</span><span class="o">)</span>
<span class="k">case</span> <span class="mf">2.0</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Low"</span><span class="o">)</span>
<span class="k">case</span> <span class="mf">1.0</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Very low"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Unknown score"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>It is more or less similar to the <code class="language-plaintext highlighter-rouge">Int</code> example. In a real world situation we will have the need to use
conditional expressions to match one or more cases.</p>
<p>The left side of the expression is used to capture the variable and also the condition matching it while the right side i.e the expression after the <code class="language-plaintext highlighter-rouge">=></code> returns a value. In the above example it returns a <code class="language-plaintext highlighter-rouge">Unit</code> since it just prints out and does not do any other computation.</p>
<p>If the execution does not match any of the cases, then it simply throws an exception.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">object</span> <span class="nc">RunExample</span> <span class="k">extends</span> <span class="nc">App</span><span class="o">{</span>
<span class="k">val</span> <span class="nv">status</span> <span class="k">=</span> <span class="mi">10</span>
<span class="n">status</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="mi">0</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"The status is false"</span><span class="o">)</span>
<span class="k">case</span> <span class="mi">1</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"The status is true"</span><span class="o">)</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<p>Executing the above code results in the following.</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="nc">Exception</span> <span class="n">in</span> <span class="n">thread</span> <span class="s">"main"</span> <span class="n">scala</span><span class="o">.</span><span class="na">MatchError</span><span class="o">:</span> <span class="mi">10</span> <span class="o">(</span><span class="n">of</span> <span class="kd">class</span> <span class="nc">java</span><span class="o">.</span><span class="na">lang</span><span class="o">.</span><span class="na">Integer</span><span class="o">)</span>
<span class="n">at</span> <span class="nc">RunExample</span><span class="err">$</span><span class="o">.</span><span class="na">delayedEndpoint</span><span class="n">$RunExample</span><span class="err">$</span><span class="mi">1</span><span class="o">(</span><span class="nc">RunExample</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">8</span><span class="o">)</span>
<span class="n">at</span> <span class="nc">RunExample</span><span class="n">$delayedInit$body</span><span class="o">.</span><span class="na">apply</span><span class="o">(</span><span class="nc">RunExample</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">3</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">Function0</span><span class="n">$class</span><span class="o">.</span><span class="na">apply</span><span class="n">$mcV$sp</span><span class="o">(</span><span class="nc">Function0</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">34</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">runtime</span><span class="o">.</span><span class="na">AbstractFunction0</span><span class="o">.</span><span class="na">apply</span><span class="n">$mcV$sp</span><span class="o">(</span><span class="nc">AbstractFunction0</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">12</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">App</span><span class="err">$</span><span class="n">$anonfun$main</span><span class="err">$</span><span class="mi">1</span><span class="o">.</span><span class="na">apply</span><span class="o">(</span><span class="nc">App</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">76</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">App</span><span class="err">$</span><span class="n">$anonfun$main</span><span class="err">$</span><span class="mi">1</span><span class="o">.</span><span class="na">apply</span><span class="o">(</span><span class="nc">App</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">76</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">collection</span><span class="o">.</span><span class="na">immutable</span><span class="o">.</span><span class="na">List</span><span class="o">.</span><span class="na">foreach</span><span class="o">(</span><span class="nc">List</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">381</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">collection</span><span class="o">.</span><span class="na">generic</span><span class="o">.</span><span class="na">TraversableForwarder</span><span class="n">$class</span><span class="o">.</span><span class="na">foreach</span><span class="o">(</span><span class="nc">TraversableForwarder</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">35</span><span class="o">)</span>
<span class="n">at</span> <span class="n">scala</span><span class="o">.</span><span class="na">App</span><span class="n">$class</span><span class="o">.</span><span class="na">main</span><span class="o">(</span><span class="nc">App</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">76</span><span class="o">)</span>
<span class="n">at</span> <span class="nc">RunExample</span><span class="err">$</span><span class="o">.</span><span class="na">main</span><span class="o">(</span><span class="nc">RunExample</span><span class="o">.</span><span class="na">scala</span><span class="o">:</span><span class="mi">3</span><span class="o">)</span>
<span class="n">at</span> <span class="nc">RunExample</span><span class="o">.</span><span class="na">main</span><span class="o">(</span><span class="nc">RunExample</span><span class="o">.</span><span class="na">scala</span><span class="o">)</span></code></pre></figure>
<h3><b><a name="Conditionals" class="inter-header">Using conditionals</a></b></h3>
<p>Taking the same example above with a broader score range.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">score</span> <span class="k">=</span> <span class="mf">8.0</span>
<span class="n">score</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">highScore</span>
<span class="k">if</span> <span class="n">highScore</span> <span class="o">>=</span> <span class="mf">8.0</span> <span class="o">&&</span> <span class="n">highScore</span> <span class="o"><=</span> <span class="mf">10.0</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"High score"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">averageScore</span>
<span class="k">if</span> <span class="n">averageScore</span> <span class="o">>=</span> <span class="mf">5.0</span> <span class="o">&&</span> <span class="n">averageScore</span> <span class="o"><</span> <span class="mf">8.0</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Average score"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">lowScore</span>
<span class="k">if</span> <span class="n">lowScore</span> <span class="o">>=</span><span class="mf">0.0</span> <span class="o">&&</span> <span class="n">lowScore</span> <span class="o"><</span> <span class="mf">5.0</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Low score"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Error. Invalid score. It has to be in the range 0.0 to 10.0"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>The variables <code class="language-plaintext highlighter-rouge">highScore</code>, <code class="language-plaintext highlighter-rouge">averageScore</code> and <code class="language-plaintext highlighter-rouge">lowScore</code> are actually doubles and can be used in the right side of the computation.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">score</span> <span class="k">=</span> <span class="mf">9.0</span>
<span class="n">score</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">highScore</span>
<span class="k">if</span> <span class="n">highScore</span> <span class="o">>=</span> <span class="mf">8.0</span> <span class="o">&&</span> <span class="n">highScore</span> <span class="o"><=</span> <span class="mf">10.0</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"High score : Got $highScore"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">averageScore</span>
<span class="k">if</span> <span class="n">averageScore</span> <span class="o">>=</span> <span class="mf">5.0</span> <span class="o">&&</span> <span class="n">averageScore</span> <span class="o"><</span> <span class="mf">8.0</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"Average score : Got $averageScore"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">lowScore</span>
<span class="k">if</span> <span class="n">lowScore</span> <span class="o">>=</span><span class="mf">0.0</span> <span class="o">&&</span> <span class="n">lowScore</span> <span class="o"><</span> <span class="mf">5.0</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"Low score : Got $lowScore"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Error. Invalid score. It has to be in the range 0.0 to 10.0"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>Since java switch case statements can take only constant values in its case’s, this is more elegant to work with. It is important to note that there is no need of a break statement since it automatically matches only of the cases present and falls back to the <code class="language-plaintext highlighter-rouge">_</code> case if there is no
match and throws an exception if there is no fallback as we saw above. Conditionals are also called guard statements similar to the guard in for comprehensions.</p>
<h3><b><a name="Strings" class="inter-header">Pattern matching strings</a></b></h3>
<p>So far we have been seeing value types. Let’s take a look at string pattern matching which is very useful(Intentionally keeping the examples simple
in order to grasp the concepts).</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">dayOfTheWeek</span> <span class="k">=</span> <span class="s">"Sunday"</span>
<span class="n">dayOfTheWeek</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="s">"Sunday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Holiday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"Saturday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Holiday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"Monday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"Tuesday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"Wednesday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"Thursday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"Friday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Invalid Day"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>If we want the comparison to be case-insensitive then,</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">dayOfTheWeek</span> <span class="k">=</span> <span class="s">"monday"</span>
<span class="n">dayOfTheWeek</span> <span class="n">toLowerCase</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="s">"sunday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Holiday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"saturday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Holiday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"monday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"tuesday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"wednesday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"thursday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="s">"friday"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Invalid Day"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>Locale should be handled correctly in the above example, but you get the idea.</p>
<p>We can optimize the above code block into something more concise as below,</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">dayOfTheWeek</span> <span class="k">=</span> <span class="s">"sunday"</span>
<span class="n">dayOfTheWeek</span> <span class="n">toLowerCase</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="s">"sunday"</span> <span class="o">|</span> <span class="s">"saturday"</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Holiday"</span><span class="o">)</span>
<span class="k">case</span>
<span class="s">"monday"</span> <span class="o">|</span> <span class="s">"tuesday"</span> <span class="o">|</span> <span class="s">"wednesday"</span> <span class="o">|</span> <span class="s">"thursday"</span> <span class="o">|</span> <span class="s">"friday"</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Weekday"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Invalid day of the week"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>The <code class="language-plaintext highlighter-rouge">|</code> is a shorthand for or condition.</p>
<h3><b><a name="CaptureValues" class="inter-header">Capturing values</a></b></h3>
<p>Each match in a pattern match block are capable of returning a value and hence the result can be stored into a variable.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">score</span> <span class="k">=</span> <span class="mf">8.0</span>
<span class="k">val</span> <span class="nv">scoreFeedback</span> <span class="k">=</span> <span class="n">score</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">highScore</span>
<span class="k">if</span> <span class="n">highScore</span> <span class="o">>=</span> <span class="mf">8.0</span> <span class="o">&&</span> <span class="n">highScore</span> <span class="o"><=</span> <span class="mf">10.0</span> <span class="k">=></span>
<span class="s">"High score"</span>
<span class="k">case</span> <span class="n">averageScore</span>
<span class="k">if</span> <span class="n">averageScore</span> <span class="o">>=</span> <span class="mf">5.0</span> <span class="o">&&</span> <span class="n">averageScore</span> <span class="o"><</span> <span class="mf">8.0</span> <span class="k">=></span>
<span class="s">"Average score"</span>
<span class="k">case</span> <span class="n">lowScore</span>
<span class="k">if</span> <span class="n">lowScore</span> <span class="o">>=</span><span class="mf">0.0</span> <span class="o">&&</span> <span class="n">lowScore</span> <span class="o"><</span> <span class="mf">5.0</span> <span class="k">=></span>
<span class="s">"Low score"</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span>
<span class="s">"Error. Invalid score. It has to be in the range 0.0 to 10.0"</span>
<span class="o">}</span></code></pre></figure>
<h3><b><a name="Options" class="inter-header">Matching with Options</a></b></h3>
<p>In case we do not want to store the error message in the result, then we can use an <code class="language-plaintext highlighter-rouge">Option</code>.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">scoreFeedback</span> <span class="k">:</span> <span class="kt">Option</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span> <span class="k">=</span> <span class="n">score</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">highScore</span>
<span class="k">if</span> <span class="n">highScore</span> <span class="o">>=</span> <span class="mf">8.0</span> <span class="o">&&</span> <span class="n">highScore</span> <span class="o"><=</span> <span class="mf">10.0</span> <span class="k">=></span>
<span class="nc">Some</span><span class="o">(</span><span class="s">"High score"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">averageScore</span>
<span class="k">if</span> <span class="n">averageScore</span> <span class="o">>=</span> <span class="mf">5.0</span> <span class="o">&&</span> <span class="n">averageScore</span> <span class="o"><</span> <span class="mf">8.0</span> <span class="k">=></span>
<span class="nc">Some</span><span class="o">(</span><span class="s">"Average score"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">lowScore</span>
<span class="k">if</span> <span class="n">lowScore</span> <span class="o">>=</span><span class="mf">0.0</span> <span class="o">&&</span> <span class="n">lowScore</span> <span class="o"><</span> <span class="mf">5.0</span> <span class="k">=></span>
<span class="nc">Some</span><span class="o">(</span><span class="s">"Low score"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span>
<span class="nf">println</span><span class="o">(</span><span class="s">"Error. Invalid score. It has to be in the range 0.0 to 10.0"</span><span class="o">)</span>
<span class="nc">None</span>
<span class="o">}</span></code></pre></figure>
<p>The results can then be pattern matched again as we saw in <a href="/blog/scala-tutorials-part-16-the-option-type/">part 16</a>.</p>
<h3><b><a name="HeterogenousMatch" class="inter-header">Heterogeneous pattern matching</a></b></h3>
<p>Pattern matching is not restricted to a particular type. Because of Scala’s robust type system, we can literally match anything that fits the type
hierarchy properly.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">monthOfYear</span> <span class="k">:</span> <span class="kt">Any</span> <span class="o">=</span> <span class="s">"January"</span>
<span class="n">monthOfYear</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="mi">1</span> <span class="o">|</span> <span class="s">"January"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"First month of the year"</span><span class="o">)</span>
<span class="k">case</span> <span class="mi">2</span> <span class="o">|</span> <span class="s">"February"</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Second month of the year"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Invalid month integer"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">:</span> <span class="kt">String</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Invalid month string"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<h3><b><a name="DecomposingTypes" class="inter-header">Decomposing types using pattern matching</a></b></h3>
<p>Another unique capability of pattern matching is to decompose an unknown type or higher type into a recognized type.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">val</span> <span class="nv">typeTest</span> <span class="k">:</span> <span class="kt">Any</span> <span class="o">=</span> <span class="s">"String"</span>
<span class="n">typeTest</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">i</span> <span class="k">:</span> <span class="kt">Int</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Integer type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">d</span> <span class="k">:</span> <span class="kt">Double</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Double type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">f</span> <span class="k">:</span> <span class="kt">Float</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Float type"</span><span class="o">)</span>
<span class="k">case</span> <span class="n">s</span> <span class="k">:</span> <span class="kt">String</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"String type"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">:</span> <span class="kt">BigDecimal</span> <span class="o">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Big decimal type"</span><span class="o">)</span>
<span class="k">case</span> <span class="k">_</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="s">"Unknown type"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>The type ascription <code class="language-plaintext highlighter-rouge">Any</code> is necessary in order for the compiler to treat it as a higher type and avoid the variable type being automatically inferred to <code class="language-plaintext highlighter-rouge">String</code>.
In real world, the type you are going to match might come from an API endpoint/from a file etc.,</p>
<h3><b><a name="CaseClass" class="inter-header">Case class matching</a></b></h3>
<p>Case classes are named after pattern matching i.e the case keyword. They are naturally suited to it because of the
<code class="language-plaintext highlighter-rouge">unapply</code> method which gets automatically generated.</p>
<p>Let’s create a textbook example of cars.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">abstract</span> <span class="k">class</span> <span class="nc">Car</span>
<span class="k">case</span> <span class="k">class</span> <span class="nc">Hyundai</span><span class="o">(</span><span class="n">name</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">Car</span>
<span class="k">case</span> <span class="k">class</span> <span class="nc">Toyota</span><span class="o">(</span><span class="n">name</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">Car</span>
<span class="k">case</span> <span class="k">class</span> <span class="nc">Audi</span><span class="o">(</span><span class="n">name</span><span class="k">:</span><span class="kt">String</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">Car</span></code></pre></figure>
<p>Let’s create an instance of this car (the type ascription is important)</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">car</span> <span class="k">:</span> <span class="kt">Car</span> <span class="o">=</span> <span class="nc">Audi</span><span class="o">(</span><span class="s">"Audi V8"</span><span class="o">)</span></code></pre></figure>
<p>We can then do a match on this variable.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="n">car</span> <span class="k">match</span> <span class="o">{</span>
<span class="k">case</span> <span class="nc">Hyundai</span><span class="o">(</span><span class="n">name</span><span class="o">)</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"$name is from South Korea"</span><span class="o">)</span>
<span class="k">case</span> <span class="nc">Toyota</span><span class="o">(</span><span class="n">name</span><span class="o">)</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"$name is from Japan"</span><span class="o">)</span>
<span class="k">case</span> <span class="nc">Audi</span><span class="o">(</span><span class="n">name</span><span class="o">)</span> <span class="k">=></span> <span class="nf">println</span><span class="o">(</span><span class="n">s</span><span class="s">"$name is from Germany"</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>We do a pattern match on the case class type with a parameter name. The parameter <code class="language-plaintext highlighter-rouge">name</code> is important since the case class cannot be created without it. You can revisit the <a href="/blog/scala-tutorials-part-6-case-classes/#Decompiled">decompiled version</a> of the case class and see the <code class="language-plaintext highlighter-rouge">unapply</code> method. It would make much more sense now and how it is useful in pattern matching. Case objects can also be matched using a
similar approach.</p>
<h3><b><a name="PTDecompiled" class="inter-header">Pattern matching decompiled</a></b></h3>
<p>We are not going to exhaustively see how pattern matching works behind the scenes for all examples. Let’s take three different examples to understand how they behave. Since the decompiled code is pretty big, I have collected both in a gist.</p>
<ul>
<li><a href="https://gist.github.com/Madusudanan/0510dfc3e18750443d34c4fed839a681" target="_blank">Decompiled with a simple pattern match</a></li>
<li><a href="https://gist.github.com/Madusudanan/13a7f69ba2b68d44cde20bd0a224603a" target="_blank">With conditionals</a></li>
<li><a href="https://gist.github.com/Madusudanan/6bdd22a6c33c384cccba7ba5d08be138" target="_blank">Example with type decomposition</a></li>
</ul>
<p><a href="https://github.com/JetBrains/intellij-community/tree/master/plugins/java-decompiler/engine" target="_blank">Fernflower decompiler</a> does a pretty good job of decompiling the code. It is interesting to see that in the first example it is being compiled to java switch statements, the second one with a bunch of if-else since switch case does not support condition based matching. The third one is done via a couple of <code class="language-plaintext highlighter-rouge">instanceOf</code> comparisons. We can see that pattern matching gives us a very nice abstraction and lets the compiler deal with the all the hardwork. The decompiled code can change as the JVM evolves and a lot of features are added natively.</p>
<h3><b><a name="Finale" class="inter-header">Finale</a></b></h3>
<p>Let’s summarize what we have seen till now.</p>
<ul>
<li>An overview of pattern matching with value types and string</li>
<li>Usage of pattern matching with case classes</li>
<li>Type decomposition with pattern matching</li>
</ul>
<p>There are more complex use cases of pattern matching in data structures such as <code class="language-plaintext highlighter-rouge">Seq</code>, <code class="language-plaintext highlighter-rouge">List</code>, <code class="language-plaintext highlighter-rouge">Vector</code> etc., I will cover those when we get to collections.</p>
<p>We are also protected from quite a few run time issues partly due to the type system of Scala and also how pattern matching by itself is designed. Next time whenever you see a switch case/complex if-else structure, think of re-writing it with pattern matching.</p>Madusudanan.B.NPattern MatchingScala Tutorials Part #22 - Substitution model of evaluation2017-09-26T00:00:00+00:002017-09-26T00:00:00+00:00http://madusudanan.com/blog/scala-tutorials-execution-model<h2 id="substitution-model-of-evaluation">Substitution model of evaluation</h2>
<p>This is part 22 of the Scala tutorial series. Check <a href="/blog/scala-articles-index/">here</a> for the full series.</p>
<p>In <a href="/blog/scala-tutorials-part-19-lambda-calculus/">part 19</a> we saw how lambda calculus was the motivation behind functional programming and many
concepts were adapted from it. In this part we are going to see what strategy Scala uses to evaluate expressions and functions which also came<br />
from lambda calculus.</p>
<p><i class="fa fa-list-ul fa-lg space-right"></i> Index</p>
<ul>
<li><a href="#Intro">Introduction</a></li>
<li><a href="#ExpressionEvaluation">Expression evaluation</a></li>
<li><a href="#FunctionEvaluation">Function evaluation</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
</ul>
<h3><b><a name="Intro" class="inter-header">Introduction</a></b></h3>
<p>Program expressions are evaluated in the same way we would evaluate a mathematical expression. It goes roughly like below,</p>
<ul>
<li>Consider operator precedence</li>
<li>Evaluation starts from left to right.</li>
<li>Apply the operators to the operands based on precedence.</li>
</ul>
<p>This is slightly different from regular languages such as Java where only a general language
rule is applied and it is not a functional language.</p>
<h3><b><a name="ExpressionEvaluation" class="inter-header">Expression evaluation</a></b></h3>
<p>Let’s take a very simple expression.</p>
<p>` (2<em>10)+(9</em>4) `</p>
<p>If you trace the execution flow, it will probably be something like below.</p>
<p>-> <code class="language-plaintext highlighter-rouge">20+(9*4)</code></p>
<p>-> <code class="language-plaintext highlighter-rouge">20+36</code></p>
<p>-> <code class="language-plaintext highlighter-rouge">56</code></p>
<p>The <code class="language-plaintext highlighter-rouge">()</code> braces come first, and hence the <code class="language-plaintext highlighter-rouge">+</code> is not calculated till <code class="language-plaintext highlighter-rouge">9*4</code> is evaluated and then finally add up with <code class="language-plaintext highlighter-rouge">20</code> and the result is <code class="language-plaintext highlighter-rouge">56</code>.
Let’s do one more which is slightly complicated with variables.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="nv">x</span> <span class="k">=</span> <span class="mi">20</span>
<span class="k">val</span> <span class="nv">y</span> <span class="k">=</span> <span class="mi">30</span>
<span class="o">(</span><span class="mi">10</span><span class="o">*</span><span class="mi">8</span><span class="o">)</span> <span class="o">/</span> <span class="n">x</span><span class="o">+</span><span class="n">y</span></code></pre></figure>
<p>-> <code class="language-plaintext highlighter-rouge">80/x+y</code></p>
<p>-> <code class="language-plaintext highlighter-rouge">80/20+y</code></p>
<p>-> <code class="language-plaintext highlighter-rouge">4+y</code></p>
<p>-> <code class="language-plaintext highlighter-rouge">4+30</code></p>
<p>-> <code class="language-plaintext highlighter-rouge">34</code></p>
<h3><b><a name="FunctionEvaluation" class="inter-header">Function evaluation</a></b></h3>
<p>In <a href="/blog/scala-tutorials-part-3-methods/#CallByNamevsValue">part 3</a>, we saw how function evaluation takes place, so I will not
be going over it again. But there is one quirky detail that I will be explaining below. (Example adapted from Functional Programming Principles in
Scala — Coursera)</p>
<p>Let’s consider a method that calls itself recursively.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">def</span> <span class="nf">loop</span><span class="k">:</span><span class="kt">Int</span> <span class="o">=</span> <span class="n">loop</span> </code></pre></figure>
<p>Another method which just returns one of the arguments passed in.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nf">test</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">y</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=</span> <span class="n">x</span></code></pre></figure>
<p>Under normal evaluation calling the <code class="language-plaintext highlighter-rouge">loop</code> method will lead to infinite loop. But what will happen if we call the <code class="language-plaintext highlighter-rouge">test</code> method?</p>
<p>Since Scala uses call-by-value as default, it would lead to infinite loop even though the second argument does not play
any role in it. <code class="language-plaintext highlighter-rouge">test(1,loop)</code> will keep on running. We can fix this by making the <code class="language-plaintext highlighter-rouge">test</code> method’s second parameter as call by name.</p>
<figure class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nf">test</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">y</span> <span class="k">:</span> <span class="o">=></span> <span class="nc">Int</span><span class="o">)</span> <span class="k">=</span> <span class="n">x</span></code></pre></figure>
<p>We <a href="/blog/scala-tutorials-part-19-lambda-calculus/#FirstClass">already saw</a> how functions can be passed in as parameters. This is nothing
but a function which expects another function i.e <code class="language-plaintext highlighter-rouge">y</code> as a parameter. These are called
<a href="https://en.wikipedia.org/wiki/Higher-order_function">Higher Order Functions</a> which we will see later.</p>
<p>Now when we call <code class="language-plaintext highlighter-rouge">test(1,loop)</code>, it evaluates to 1 since it resorts to lazy evaluation behind the scenes and does not evaluate the <code class="language-plaintext highlighter-rouge">loop</code> function.</p>
<h3><b><a name="Conclusion" class="inter-header">Conclusion</a></b></h3>
<p>This evaluation strategy is buried deep under the depths of the Scala compiler. There is a lot more to it than what is mentioned in this article.
But let’s summarize.</p>
<ul>
<li>Scala’s evaluation strategy is modeled from lambda calculus</li>
<li>Expressions are evaluated from left to right and follow operator precedence</li>
<li>Functions are evaluated using Call by Value, but can also be changed to use Call by Name depending on where it is necessary</li>
</ul>
<p>This knowledge is immensely useful if you are designing libraries in Scala. In a general day to day programming, it is good to know
but not really necessary to worry about it too much.</p>Madusudanan.B.NSubstitution model of evaluation