<link>http://pramo.info/</link></image><item><title>Towards Fairer Retirement Outcomes: Health-Related Mortality Modelling</h1> <article> <h1>Towards Fairer Retirement Outcomes: Health-Related Mortality Modelling</h1> <p>Wed, 27 May 2026 14:30:00 +1000</p> </article> <article> <h1>Mortality Research Published: Modelling Socio-economic Differences in Australia</h1> <p>Sun, 17 May 2026 00:00:00 +0000</p> <p>I’m very pleased to share that our Actuaries Institute research paper, <strong> </strong>, is now available.</p> <p>The paper explores how socio-economic characteristics can be incorporated into mortality modelling in Australia. That matters because mortality assumptions are not just abstract technical inputs. They shape retirement income projections, insurance pricing, capital decisions, public policy analysis, and the way actuaries think about fairness across different communities.</p> <p>Alongside the paper, we have also released the <strong> </strong>, an interactive tool for exploring projected life expectancy and annuity income under different demographic and socio-economic profiles. It is designed to make the research more usable: not only as a paper to read, but as a model to interrogate, test, and discuss.</p> <h2 id="my-contribution">My Contribution</h2> <p>This project brings together several areas I care deeply about: actuarial judgement, statistical modelling, public-interest research, and practical tools that help people understand complex risk.</p> <p>I contributed to the work as part of the research team and helped develop the interactive explorer experience, including the medical explorer component. Building tools like this is the kind of actuarial work I find most meaningful: rigorous enough to support professional decision-making, but accessible enough to invite better questions from people outside the modelling process.</p> <h2 id="why-this-matters">Why This Matters</h2> <p>Mortality modelling is often discussed in aggregate, but real lives are not aggregate. Socio-economic differences can affect longevity in ways that are material for retirement outcomes, product design, and policy decisions. Models that recognise those differences can help actuaries ask sharper questions about equity, sustainability, and the assumptions sitting behind financial advice and institutional decisions.</p> <p>For me, this publication is a milestone because it sits at the intersection of research and application. It is also a reminder of the kind of career I want to keep building: technically strong, socially aware, and useful in practice.</p> <p>You can read the paper through the Actuaries Institute and explore the interactive tool here:</p> <ul> <li><strong>Research paper:</strong> </li> <li><strong>Interactive tool:</strong> </li> </ul> </article> <article> <h1>Mentorship: A New Chapter with the Actuaries Institute</h1> <p>Thu, 19 Mar 2026 12:00:00 +0000</p> <p>I am thrilled to share that I have been selected as a mentee for the 2026 Actuaries Institute Mentoring Program!</p> <p>As an Associate (AIAA), I am looking forward to connecting with an experienced Fellow to gain broader industry insights and refine my professional goals. This program is a fantastic opportunity to bridge the gap between academic theory and real-world actuarial practice.</p> <p>I’ll be back in six months to write a full summary of my experience, the lessons learned, and the key takeaways from this journey.</p> <p>Stay tuned for the update in September!</p> </article> <article> <h1>Empowering the Next Generation: ASOC First Year Panel & Exemptions</h1> <p>Thu, 26 Feb 2026 14:00:00 +0000</p>  </article> <article> <h1>It's Official: I Have Graduated!</h1> <p>Tue, 24 Feb 2026 00:00:00 +0000</p> <p>It’s official: I have graduated!</p> <p>I’ve spent a lot of time reflecting on what to say for this post. For a while, I felt the pressure of the “average” timeline: the idea that you should be in and out of university in three or four years. But as I stand here today, I realise I didn’t just graduate; I built a foundation that I am immensely proud of.</p> <p>It wasn’t a delay; it was a deep dive.</p> <p>I’m thrilled to share that I have officially graduated from the Australian National University with the following:</p> <ul> <li>Bachelor of Computing (Honours)</li> <li>Bachelor of Science</li> <li>Bachelor of Actuarial Studies</li> </ul> <p>Beyond the three parchments, this journey was defined by the experiences between the lectures: the research internships, the tutoring, the mentorships, and the joy of founding the ANU Sri Lankan Society.</p> <p>One of my proudest milestones was qualifying for my Associateship with the Actuaries Institute (AIAA) while navigating the rigors of full-time study. Over the last three years, I consistently chose to overload, pushing my limits to commit to long-term professional goals. It was the ultimate masterclass in time management, but more importantly, it was fueled by a genuine passion for learning.</p> <p>This drive isn’t just academic; it spills into every aspect of my life. It’s the same curiosity that led me to start numerous projects over the years: from learning sign language to teaching myself how to bake the local Sri Lankan foods I couldn’t find nearby. I’ve realised that I don’t just want the result; I love the “how.”</p> <p>As a third-generation graduate, I take immense pride in education. My path was the “scenic route,” but it taught me that the most valuable skill isn’t just knowing the answer: it’s having the resilience to find it.</p> <p>The girl who enrolled in 2019 because she “needed to” has grown to love learning. I graduate today still eager, still curious, and ready for the many milestones yet to be met.</p> <p>To anyone who feels like they are “behind”: Your timeline is yours to write. A huge thank you to my family, my partner, and everyone at ANU who supported this rewarding journey. On to the next chapter! 🥂</p> </article> <article> <h1>Presenting at the All Actuaries Summit 2026</h1> <p>Tue, 10 Feb 2026 00:00:00 +0000</p> <p>I’m honoured to present my recent work on state-based dynamic probabilistic mortality models at the All Actuaries Summit 2026. The session will cover how national-scale health data can improve individual-level mortality forecasts and the implications for retirement planning and policymaking.</p> <p>If you’d like to follow up or see the slides after the conference, please check back here or reach out via the contact links on my profile.</p> </article> <article> <h1>Climate and Sustainability Learning Resource (Ongoing)</h1> <p>Tue, 02 Dec 2025 00:00:00 +0000</p> <p>This ongoing learning resource provided by the Actuaries Institute focuses on the critical intersection of climate change, environmental sustainability, and actuarial science. The syllabus covers methodologies for evaluating climate risks, modeling the financial impacts of environmental shifts, and developing sustainable strategies for long-term planning. It equips professionals with the necessary knowledge to integrate climate-related data into core actuarial workflows.</p> </article> <article> <h1>2025 Australasian Actuarial Education and Research Symposium - Talk</h1> <p>Mon, 01 Dec 2025 14:30:00 +0000</p> </article> <article> <h1>AI and Data Science Learning Resource (Ongoing)</h1> <p>Mon, 01 Dec 2025 00:00:00 +0000</p> <p>This comprehensive training resource dives into modern data science and artificial intelligence techniques, tailored specifically for actuarial applications. It provides practical skills in building predictive models, leveraging advanced machine learning algorithms, and conducting deep data analytics. The program is designed to enhance traditional actuarial methodologies by integrating cutting-edge AI technologies, improving accuracy and efficiency in complex modeling tasks.</p> </article> <article> <h1>Rethinking Mortality: A State-Based Dynamic Probabilistic Modelling Approach Using National-Scale Health Data</h1> <p>Thu, 30 Oct 2025 00:00:00 +0000</p> <h2 id="overview">Overview</h2> <p>[cite_start]This thesis argues that disease-centred mortality models—incorporating health conditions, medical procedures, and medication histories—offer significantly enhanced predictive accuracy for retiree mortality compared to conventional models relying solely on age and gender[cite: 102].</p> <h3 id="key-findings">Key Findings</h3> <ul> <li>[cite_start]<strong>Improved Accuracy</strong>: The proposed models outperformed the Australian Life Tables (ALT) benchmark in both individual-level predictions and cohort-level forecasts[cite: 667].</li> <li>[cite_start]<strong>Financial Impact</strong>: For a cohort of 100,000 retirees, the proportion expected to outlive their planning horizon falls from 9.9% (ALT) to 6.7% with this model[cite: 73].</li> <li>[cite_start]<strong>National Policy</strong>: Implementing these models could decrease Age Pension expenditure by approximately $83.2 million per year by improving retirement drawdown strategies[cite: 74].</li> </ul> <h2 id="full-thesis">Full Thesis</h2> <p>The full thesis PDF is embedded below for convenient reading.</p> <div style="margin-top:1rem;"> <p><strong>Full thesis (PDF):</strong> <a href="thesis.pdf" target="_blank" rel="noopener">Download the thesis (PDF)</a></p> </div> </article> <article> <h1>AI, ML and Friends Seminar - Talk</h1> <p>Fri, 15 Aug 2025 13:00:00 +0000</p> </article> <article> <h1>ANU Actuarial School Brownbag Seminar- Talk</h1> <p>Sat, 10 May 2025 12:00:00 +0000</p> </article> <article> <h1>Error 101</h1> <p>Sat, 04 May 2024 00:00:00 +0000</p> <h2 id="errors-101">Errors 101</h2> <p>Everyone makes mistakes all the time, and this is especially true for coding. Being able to understand error messages is one of the most important aspects of writing code; how can you hope to fix your program if you don’t know whats wrong with it?</p> <h3 id="reading-error-messages">Reading error messages</h3> <h4 id="example-1">Example 1</h4> <p>Let’s start off simple. Assume that the following is an example of a function that outputs the second element of a list:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">secondElem</span> <span class="ow">::</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"><span class="nf">secondElem</span> <span class="n">list</span> <span class="ow">=</span> <span class="kr">case</span> <span class="n">list</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="ne">error</span> <span class="s">" list is too short"</span> </span></span><span class="line"><span class="cl"> <span class="n">x</span><span class="kt">:</span><span class="n">y</span><span class="kt">:</span><span class="n">xs</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">y</span> </span></span></code></pre></div><p>No error would occur in compiling this code. However, if we run <code>secondElem [1]</code> we would get the following error message:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="o">***</span> <span class="kt">Exception:</span> <span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">19</span><span class="p">)</span><span class="o">-</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span><span class="mi">15</span><span class="p">)</span><span class="kt">:</span> <span class="kt">Non</span><span class="o">-</span><span class="n">exhaustive</span> <span class="n">patterns</span> <span class="kr">in</span> <span class="kr">case</span> </span></span></code></pre></div><p>This is simply saying that there is at least one “case” for which the pattern matching of the function has not been defined. Note that here <code>Comp1100.hs</code> refers to the name of the haskell file, <code>(2,19)-(4,15)</code> refers to the range in which this error occurs, that is <strong>from the 19th character of the second line, to the 15th chartacter of the 4th line</strong>. In short haskell tends to use the structure <code>(line number,character number)</code> to represent these locations.</p> <h4 id="example-2">Example 2</h4> <p>Finding the maximum of two numbers with the use of guards:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">maxWithGuards</span> <span class="ow">::</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"><span class="nf">maxWithGuards</span> <span class="n">a</span> <span class="n">b</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="p">(</span><span class="n">a</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">b</span><span class="p">)</span> <span class="ow">=</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">otherwise</span> <span class="ow">=</span> <span class="n">b</span> </span></span></code></pre></div><p>When compiling the above code we get the following error:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">19</span><span class="kt">:</span><span class="mi">8</span><span class="kt">:</span> <span class="ne">error</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">No</span> <span class="kr">instance</span> <span class="n">for</span> <span class="p">(</span><span class="kt">Ord</span> <span class="n">a</span><span class="p">)</span> <span class="n">arising</span> <span class="n">from</span> <span class="n">a</span> <span class="n">use</span> <span class="kr">of</span> <span class="p">`</span><span class="o">&</span><span class="n">gt</span><span class="p">;</span><span class="sc">'</span> </span></span><span class="line"><span class="cl"> <span class="kt">Possible</span> <span class="n">fix</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="n">add</span> <span class="p">(</span><span class="kt">Ord</span> <span class="n">a</span><span class="p">)</span> <span class="n">to</span> <span class="n">the</span> <span class="n">context</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="n">the</span> <span class="kr">type</span> <span class="n">signature</span> <span class="n">for</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="n">maxWithGuards</span> <span class="ow">::</span> <span class="n">forall</span> <span class="n">a</span><span class="o">.</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">In</span> <span class="n">the</span> <span class="n">expression</span><span class="kt">:</span> <span class="p">(</span><span class="n">a</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">b</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="kt">In</span> <span class="n">a</span> <span class="n">stmt</span> <span class="kr">of</span> <span class="n">a</span> <span class="n">pattern</span> <span class="n">guard</span> <span class="n">for</span> </span></span><span class="line"><span class="cl"> <span class="n">an</span> <span class="n">equation</span> <span class="n">for</span> <span class="p">`</span><span class="n">maxWithGuards'</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="p">(</span><span class="n">a</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">b</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="kt">In</span> <span class="n">an</span> <span class="n">equation</span> <span class="n">for</span> <span class="p">`</span><span class="n">maxWithGuards'</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="n">maxWithGuards</span> <span class="n">a</span> <span class="n">b</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="p">(</span><span class="n">a</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">b</span><span class="p">)</span> <span class="ow">=</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">otherwise</span> <span class="ow">=</span> <span class="n">b</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> </span></span><span class="line"><span class="cl"><span class="mi">19</span> <span class="o">|</span> <span class="o">|</span> <span class="p">(</span><span class="n">a</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">b</span><span class="p">)</span> <span class="ow">=</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="o">^^^^^</span> </span></span></code></pre></div><p>Lets analyse this line by line: <code>Comp1100.hs:19:8</code> denotes the location of the error. In other words this means <code>in the 8th character of the 19th line in the haskell file titled Comp1100.hs</code>. <code>No instance for (Ord a) arising from a use of `>'</code> This indicates that the use of “>” symbol requires the Ord character, and there is no instance of ord defined for the varibale provided. Notice the type signature of the function to be <code>maxWithGuards :: a -> a -> a</code> In the error message we see the line: <code>maxWithGuards :: forall a. a -> a -> a</code> This is haskell telling you that the type signature has been defined for <strong>all</strong> types of a, and hence it should run for code such as <code>maxWithGuards True False</code> but it wouldn’t be able to evaluate the answer to <strong>True > False</strong> as it clearly makes no sense. Haskell has also included a ‘possible fix’ and has mentioned that we should <code>add (Ord a) to the context of the type signature</code> which is simply highlighting the need of the (Ord a) to specify a smaller set of types which are allowed to be used for the function.</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">maxWithGuards</span> <span class="ow">::</span> <span class="p">(</span><span class="kt">Ord</span> <span class="n">a</span><span class="p">)</span> <span class="o">=&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"><span class="nf">maxWithGuards</span> <span class="n">a</span> <span class="n">b</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="p">(</span><span class="n">a</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">b</span><span class="p">)</span> <span class="ow">=</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">otherwise</span> <span class="ow">=</span> <span class="n">b</span> </span></span></code></pre></div><h4 id="example-3">Example 3</h4> <p>The following example is another along the same lines as the previous example except this time instead of considering errors in the type signature, lets look into errors in data declaration. Lets assume you wanted to define a data constructor called <code>Options</code> that was either Yes or No. If we attempt to define this without capitalisation we will see this:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"> <span class="kt">Not</span> <span class="n">a</span> <span class="kr">data</span> <span class="n">constructor</span><span class="kt">:</span> <span class="p">`</span><span class="n">yes'</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> </span></span><span class="line"><span class="cl"><span class="mi">3</span> <span class="o">|</span> <span class="kr">data</span> <span class="kt">Options</span> <span class="ow">=</span> <span class="n">yes</span> <span class="o">|</span> <span class="n">no</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="o">^^^</span> </span></span></code></pre></div><p>Hence, all data type definitions must begin with a capital letter.</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kr">data</span> <span class="kt">Options</span> <span class="ow">=</span> <span class="kt">Yes</span> <span class="o">|</span> <span class="kt">No</span> </span></span></code></pre></div><p>Further, if we were to run the following code:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">oneZero</span> <span class="ow">::</span> <span class="kt">Int</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Options</span> </span></span><span class="line"><span class="cl"><span class="nf">oneZero</span> <span class="n">n</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="mi">1</span> <span class="ow">=</span> <span class="n">yes</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="mi">0</span> <span class="ow">=</span> <span class="n">no</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">otherwise</span> <span class="ow">=</span> <span class="ne">error</span> </span></span></code></pre></div><p>We would see this error:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">7</span><span class="kt">:</span><span class="mi">11</span><span class="kt">:</span> <span class="ne">error</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">Variable</span> <span class="n">not</span> <span class="kr">in</span> <span class="n">scope</span><span class="kt">:</span> <span class="n">yes</span> <span class="ow">::</span> <span class="kt">Options</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">Perhaps</span> <span class="n">you</span> <span class="n">meant</span> <span class="kr">data</span> <span class="n">constructor</span> <span class="p">`</span><span class="kt">Yes'</span> <span class="p">(</span><span class="n">line</span> <span class="mi">3</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> </span></span><span class="line"><span class="cl"><span class="mi">7</span> <span class="o">|</span> <span class="o">|</span> <span class="mi">1</span> <span class="ow">=</span> <span class="n">yes</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="o">^^^</span> </span></span><span class="line"><span class="cl"> </span></span><span class="line"><span class="cl"><span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">8</span><span class="kt">:</span><span class="mi">11</span><span class="kt">:</span> <span class="ne">error</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">Variable</span> <span class="n">not</span> <span class="kr">in</span> <span class="n">scope</span><span class="kt">:</span> <span class="n">no</span> <span class="ow">::</span> <span class="kt">Options</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">Perhaps</span> <span class="n">you</span> <span class="n">meant</span> <span class="n">one</span> <span class="kr">of</span> <span class="n">these</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="p">`</span><span class="n">n'</span> <span class="p">(</span><span class="n">line</span> <span class="mi">6</span><span class="p">),</span> <span class="kr">data</span> <span class="n">constructor</span> <span class="p">`</span><span class="kt">No'</span> <span class="p">(</span><span class="n">line</span> <span class="mi">3</span><span class="p">),</span> </span></span><span class="line"><span class="cl"> <span class="p">`</span><span class="n">not'</span> <span class="p">(</span><span class="n">imported</span> <span class="n">from</span> <span class="kt">Prelude</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> </span></span><span class="line"><span class="cl"><span class="mi">8</span> <span class="o">|</span> <span class="o">|</span> <span class="mi">0</span> <span class="ow">=</span> <span class="n">no</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="o">^^</span> </span></span><span class="line"><span class="cl"><span class="kt">Failed</span><span class="p">,</span> <span class="n">no</span> <span class="n">modules</span> <span class="n">loaded</span><span class="o">.</span> </span></span></code></pre></div><p>Crickey!</p> <p>This error message is stating the fact that the outputs yes and no have been mentioned without a capital, so haskell indentifies them as variables instead of data constructors. Hence, in order for them to be identified as data constructors we must use “Yes” and “No” whenever we want to reference the data type.</p> <h4 id="example-4">Example 4</h4> <p>Moving on to another common error, have Look at the following code and try to see if you can spot the error:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">head1</span> <span class="ow">::</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"><span class="nf">head1</span> <span class="n">list</span> <span class="ow">=</span> <span class="kr">case</span> <span class="n">list</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="ne">error</span> </span></span><span class="line"><span class="cl"> <span class="n">x</span><span class="kt">:</span><span class="kr">_</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">x</span> </span></span></code></pre></div><p>Tricky isn’t it? So when we compile the code, haskell throws the following error message at you:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">63</span><span class="kt">:</span><span class="mi">11</span><span class="kt">:</span> <span class="ne">error</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">Couldn't</span> <span class="n">match</span> <span class="n">expected</span> <span class="kr">type</span> <span class="p">`</span><span class="n">a'</span> <span class="n">with</span> <span class="n">actual</span> <span class="kr">type</span> <span class="p">`[</span><span class="kt">Char</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a0'</span> </span></span><span class="line"><span class="cl"> <span class="p">`</span><span class="n">a'</span> <span class="n">is</span> <span class="n">a</span> <span class="n">rigid</span> <span class="kr">type</span> <span class="n">variable</span> <span class="n">bound</span> <span class="n">by</span> </span></span><span class="line"><span class="cl"> <span class="n">the</span> <span class="kr">type</span> <span class="n">signature</span> <span class="n">for</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="n">head1</span> <span class="ow">::</span> <span class="n">forall</span> <span class="n">a</span><span class="o">.</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"> <span class="n">at</span> <span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">61</span><span class="kt">:</span><span class="mi">1</span><span class="o">-</span><span class="mi">17</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">In</span> <span class="n">the</span> <span class="n">expression</span><span class="kt">:</span> <span class="ne">error</span> </span></span><span class="line"><span class="cl"> <span class="kt">In</span> <span class="n">a</span> <span class="kr">case</span> <span class="n">alternative</span><span class="kt">:</span> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="ne">error</span> </span></span><span class="line"><span class="cl"> <span class="kt">In</span> <span class="n">the</span> <span class="n">expression</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="kr">case</span> <span class="n">list</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="ne">error</span> </span></span><span class="line"><span class="cl"> <span class="n">x</span> <span class="kt">:</span> <span class="kr">_</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">x</span> </span></span><span class="line"><span class="cl"> <span class="o">*</span> <span class="kt">Relevant</span> <span class="n">bindings</span> <span class="n">include</span> </span></span><span class="line"><span class="cl"> <span class="n">list</span> <span class="ow">::</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">(</span><span class="n">bound</span> <span class="n">at</span> <span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">62</span><span class="kt">:</span><span class="mi">7</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="n">head1</span> <span class="ow">::</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="p">(</span><span class="n">bound</span> <span class="n">at</span> <span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">62</span><span class="kt">:</span><span class="mi">1</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> </span></span><span class="line"><span class="cl"><span class="mi">63</span> <span class="o">|</span> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="ne">error</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="o">^^^^^</span> </span></span></code></pre></div><p>So what does this message tell you? As discussed earlie the first part shows the location of the error (11th character of the 63rd line), but the rest is a bit cryptic. <code>Couldn't match expected type `a' with actual type `[Char] -> a0'</code> This indicates that the problem here is the fact that <code>error</code> is of type <code>[Char] -> a0</code>, but we require type <code>a0</code>.</p> <p>Just like everything else in haskell, <code>error</code> is a function too. <code>error</code> is a predefined function that takes a string and generates a error message, so in order to get an error message we need to provide a string to the error function. By simply altering the code to the following, we will no longer receive an error:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">head1</span> <span class="ow">::</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"><span class="nf">head1</span> <span class="n">list</span> <span class="ow">=</span> <span class="kr">case</span> <span class="n">list</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="ne">error</span> <span class="s">"empty list!"</span> </span></span><span class="line"><span class="cl"> <span class="n">x</span><span class="kt">:</span><span class="kr">_</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">x</span> </span></span></code></pre></div><p>All of that huge error message just to say you’ve forgotten one string!</p> <h4 id="example-5">Example 5</h4> <p>The following is another important error to understand.</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kt">Comp1100</span><span class="o">.</span><span class="n">hs</span><span class="kt">:</span><span class="mi">65</span><span class="kt">:</span><span class="mi">1</span><span class="kt">:</span> <span class="ne">error</span><span class="kt">:</span> </span></span><span class="line"><span class="cl"> <span class="n">parse</span> <span class="ne">error</span> <span class="p">(</span><span class="n">possibly</span> <span class="n">incorrect</span> <span class="n">indentation</span> <span class="n">or</span> <span class="n">mismatched</span> <span class="n">brackets</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> </span></span><span class="line"><span class="cl"><span class="mi">65</span> <span class="o">|</span> <span class="n">addInt</span> <span class="ow">::</span> <span class="kt">Int</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Int</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Int</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="o">^</span> </span></span><span class="line"><span class="cl"><span class="kt">Failed</span><span class="p">,</span> <span class="n">no</span> <span class="n">modules</span> <span class="n">loaded</span><span class="o">.</span> </span></span></code></pre></div><p>Generally, <code>parse error</code> refers to either incorrect indentation or mismatched brackets in your code. In addition to mentioning this haskell gives you another clue inorder to identify this error:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"> <span class="o">|</span> </span></span><span class="line"><span class="cl"><span class="mi">65</span> <span class="o">|</span> <span class="n">addInt</span> <span class="ow">::</span> <span class="kt">Int</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Int</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Int</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="o">^</span> </span></span></code></pre></div><p>The arrow pointing to the first character of the line indicates that the error is actually somewhere above it in the code (in this case the error should be in the function defined prior to line 65).</p> <h3 id="debugging">Debugging</h3> <p>Now that you have some idea on how to read errors, it is your turn to try it out for yourself. For the following code, it is your job to determine if there is a problem with the code, and if there is, what kind of error message would ghci return? Feel free to use your newfound debugging skill to fix the functions that are broken!</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">divide</span> <span class="ow">::</span> <span class="p">(</span><span class="kt">Num</span> <span class="n">a</span><span class="p">)</span> <span class="o">=&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> </span></span><span class="line"><span class="cl"><span class="nf">divide</span> <span class="n">x</span> <span class="n">y</span> <span class="ow">=</span> <span class="n">x</span> <span class="o">/</span> <span class="n">y</span> </span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">filterLists</span> <span class="ow">::</span> <span class="p">[[</span><span class="n">a</span><span class="p">]]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">([</span><span class="n">a</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Bool</span><span class="p">)</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">[[</span><span class="n">a</span><span class="p">]]</span> </span></span><span class="line"><span class="cl"><span class="nf">filterLists</span> <span class="n">lst</span> <span class="n">fn</span> <span class="ow">=</span> <span class="kr">case</span> <span class="p">(</span><span class="n">fn</span> <span class="p">(</span><span class="n">head</span> <span class="n">lst</span><span class="p">))</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="kt">True</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">[</span><span class="n">head</span> <span class="n">lst</span><span class="p">]</span> <span class="o">++</span> <span class="n">filterLists</span><span class="p">(</span><span class="n">tail</span> <span class="n">lst</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> <span class="kt">False</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">filterLists</span> <span class="p">(</span><span class="n">tail</span> <span class="n">lst</span><span class="p">)</span> </span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">magicNumber</span> <span class="ow">::</span> <span class="p">(</span><span class="kt">Num</span> <span class="n">a</span><span class="p">)</span> <span class="o">=&</span><span class="n">gt</span><span class="p">;</span> <span class="n">a</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">[</span><span class="kt">Char</span><span class="p">]</span> </span></span><span class="line"><span class="cl"><span class="nf">magicNumber</span> <span class="n">num</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">num</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="mi">25</span> <span class="o">||</span> <span class="n">num</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="mi">60</span> <span class="ow">=</span> <span class="s">"Not even close"</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="p">(</span><span class="n">num</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="mi">25</span> <span class="o">&&</span> <span class="n">num</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="mi">35</span><span class="p">)</span> <span class="o">||</span> <span class="p">(</span><span class="n">num</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="mi">60</span> <span class="o">&&</span> <span class="n">num</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="mi">48</span><span class="p">)</span> <span class="ow">=</span> <span class="s">"Getting warmer"</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="p">(</span><span class="n">num</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="mi">35</span> <span class="o">&&</span> <span class="n">num</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="mi">41</span><span class="p">)</span> <span class="o">||</span> <span class="p">(</span><span class="n">num</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="mi">48</span> <span class="o">&&</span> <span class="n">num</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="mi">43</span><span class="p">)</span> <span class="ow">=</span> <span class="s">"Very close"</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">num</span> <span class="o">==</span> <span class="mi">42</span> <span class="ow">=</span> <span class="s">"You got it!"</span> </span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">listOfThree</span> <span class="ow">::</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Bool</span> </span></span><span class="line"><span class="cl"><span class="nf">listOfThree</span> <span class="n">lst</span> <span class="ow">=</span> <span class="kr">case</span> <span class="n">lst</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">False</span> </span></span><span class="line"><span class="cl"> <span class="n">x</span><span class="kt">:[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">False</span> </span></span><span class="line"><span class="cl"> <span class="n">x</span><span class="kt">:</span><span class="n">y</span><span class="kt">:[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span><span class="kt">False</span> </span></span><span class="line"><span class="cl"> <span class="n">x</span><span class="kt">:</span><span class="n">y</span><span class="kt">:</span><span class="n">z</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">True</span> </span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kr">data</span> <span class="kt">Apple</span> <span class="ow">=</span> <span class="kt">Green</span> <span class="o">|</span> <span class="kt">Red</span> </span></span><span class="line"><span class="cl"><span class="kr">type</span> <span class="kt">Result</span> <span class="ow">=</span> <span class="p">(</span><span class="kt">Apple</span><span class="p">,</span><span class="kt">Integer</span><span class="p">)</span> </span></span><span class="line"><span class="cl"> </span></span><span class="line"><span class="cl"><span class="nf">greenOrRed</span> <span class="ow">::</span> <span class="p">[</span><span class="kt">Apple</span><span class="p">]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">(</span><span class="kt">Result</span><span class="p">,</span> <span class="kt">Result</span><span class="p">)</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="kt">Result</span> </span></span><span class="line"><span class="cl"><span class="nf">greenOrRed</span> <span class="n">apples</span> <span class="p">((</span><span class="kr">_</span><span class="p">,</span><span class="n">x</span><span class="p">),(</span><span class="kr">_</span><span class="p">,</span><span class="n">y</span><span class="p">))</span> <span class="ow">=</span> <span class="kr">case</span> <span class="n">apples</span> <span class="kr">of</span> </span></span><span class="line"><span class="cl"> <span class="kt">[]</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="ne">error</span> <span class="s">"Empty list"</span> </span></span><span class="line"><span class="cl"> <span class="n">a</span><span class="kt">:[]</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">a</span> <span class="o">==</span> <span class="kt">Red</span> <span class="o">||</span> <span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">y</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">(</span><span class="kt">Red</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="mi">1</span><span class="p">))</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">a</span> <span class="o">==</span> <span class="kt">Red</span> <span class="o">||</span> <span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="n">y</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">(</span><span class="kt">Green</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">))</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">a</span> <span class="o">==</span> <span class="kt">Green</span> <span class="o">||</span> <span class="p">(</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="o">&</span><span class="n">gt</span><span class="p">;</span> <span class="n">x</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">(</span><span class="kt">Red</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">))</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">a</span> <span class="o">==</span> <span class="kt">Green</span> <span class="o">||</span> <span class="p">(</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="n">x</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="p">(</span><span class="kt">Green</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">))</span> </span></span><span class="line"><span class="cl"> <span class="n">a</span><span class="kt">:</span><span class="n">as</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">a</span> <span class="o">==</span> <span class="kt">Red</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">greenOrRed</span> <span class="n">as</span> <span class="p">((</span><span class="kt">Red</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="mi">1</span><span class="p">)),</span> <span class="p">(</span><span class="kt">Green</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">)))</span> </span></span><span class="line"><span class="cl"> <span class="o">|</span> <span class="n">a</span> <span class="o">==</span> <span class="kt">Green</span> <span class="o">-&</span><span class="n">gt</span><span class="p">;</span> <span class="n">greenOrRed</span> <span class="n">as</span> <span class="p">((</span><span class="kt">Red</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">)),</span> <span class="p">(</span><span class="kt">Green</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">)))</span> </span></span></code></pre></div> </article> <article> <h1>RG146 - Generic Knowledge</h1> <p>Wed, 01 May 2024 00:00:00 +0000</p> <h2 id="overview">Overview</h2> <p>I am currently enrolled in the <strong>RG146 - Generic Knowledge</strong> module, with an expected completion around mid-year.</p> <p>RG146 is the baseline training standard established by the Australian Securities and Investments Commission (ASIC) for professionals who provide financial product advice to retail clients. The Generic Knowledge module acts as the foundational tier of this compliance standard, providing a rigorous overview of the financial services landscape.</p> <h3 id="what-is-covered">What is Covered?</h3> <p>This comprehensive module focuses on the economic environment and the structural framework of financial markets. Key topics include:</p> <ul> <li><strong>The Economic Environment:</strong> Understanding macroeconomic indicators, government monetary/fiscal policy, and how they drive financial market behavior.</li> <li><strong>Financial Markets:</strong> The operation, structure, and dynamics of both Australian and international financial markets.</li> <li><strong>Financial Products:</strong> A detailed overview of fundamental asset classes, including equities, fixed interest, property, and cash.</li> <li><strong>Industry Regulation:</strong> The legal and ethical framework governing the provision of financial services in Australia, focusing on the Corporations Act and ASIC’s regulatory role.</li> </ul> <p>Completing this module will complement my actuarial and data modeling background by ensuring a robust, formalized understanding of regulatory compliance and the broader financial advisory ecosystem.</p> </article> <article> <h1>Introduction to Haskell</h1> <p>Thu, 07 Mar 2024 00:00:00 +0000</p> <h2 id="introduction-to-haskell">INTRODUCTION TO Haskell</h2> <p>This document works you through all the Haskell code used in lectures and tutorials, explaining how to read and understand the code provided.</p> <p>Before we jump into the code from lectures, let’s run through a simple example. Let’s try to write a code to calculate the sum of three integers. Haskell functions are like functions in math, so we can start there, how would you write this function in math, image .</p> <p>Here, we specify the variables within parentheses, in contrast Haskell identifies the separation of variables with spaces. So we can write the same function using Haskell as <code>f x y z = x + y + z</code> .</p> <p>Additionally, we need to specify the type signature of the function. In Haskell we use <code>::</code> to do this. For example, if we have <code>function:: Int -> Bool</code> this tells the compiler that there is a function called function of type <code>Int -> Bool</code> . All Haskell functions take an arbitrary number of inputs and return a single output. This is denoted in the type signature. Each input and output is separated with <code>-></code> sign. For example, <code>function:: Int -> Bool</code> says that “function” is a function that takes an <code>Int</code> as input and returns a <code>Bool</code> as output. With this let’s go back to write the function <code>f</code> . We know that <code>f</code> takes in three <code>Int</code> s and gives an <code>Int</code> as output, hence we can write the type signature of the function as <code>f:: Int -> Int -> Int -> Int</code> where the first three <code>Int</code> denote the inputs and the last one denotes the output. Putting it all together, we get :</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">f</span><span class="ow">::</span> <span class="kt">Int</span> <span class="ow">-></span> <span class="kt">Int</span> <span class="ow">-></span> <span class="kt">Int</span> <span class="ow">-></span> <span class="kt">Int</span> </span></span><span class="line"><span class="cl"><span class="nf">f</span> <span class="n">x</span> <span class="n">y</span> <span class="n">z</span> <span class="ow">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span> <span class="o">+</span> <span class="n">z</span> </span></span></code></pre></div><p>We wrote our first Haskell function!!!</p> <p>Let’s see what would happen if we run <code>f(3,4,5)</code> , in this case the variable <code>x</code> takes the value 3, <code>y</code> takes the value 4 and <code>z</code> takes the value 5. Using this Haskell will evaluate <code>x+y+z</code> which would be <code>3+4+5</code> and return <code>12</code> .</p> <p>For this course we only require an understanding of the syntax to be able to understand and interpret code, from here on I explaine code that was provided both in lectures and in practicals. For each bit of code, I will start off by mentioning the reference to the lecture or practical and the page it’s found (with a link that can be clicked on), then provide the code and guide you through understanding the code.</p> <p>Let’s start with lecture code, First Order Logic page 30</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">sfz</span> <span class="ow">::</span> <span class="kt">Int</span> <span class="ow">-></span> <span class="kt">Int</span> </span></span><span class="line"><span class="cl"><span class="nf">sfz</span> <span class="mi">0</span> <span class="ow">=</span> <span class="mi">0</span> </span></span><span class="line"><span class="cl"><span class="nf">sfz</span> <span class="n">n</span> <span class="ow">=</span> <span class="n">n</span> <span class="o">+</span> <span class="n">sfz</span> <span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> </span></span></code></pre></div><p>Applying the concepts taught above, we know the type signature of this code. <code>sfz :: Int -> Int</code> says that “sfz” is a function that takes an <code>Int</code> as an input and returns an <code>Int</code> as an output. The lines after the signature show the function definition: what the function does. <code>sfz 0 = 0</code> says that if 0 is passed as an argument to the function “sfz” then the output would be <code>0</code> . <code>sfz n = n + sfz (n-1)</code> says that if <code>n</code> is provided as input, then the output is <code>n + sfz (n-1)</code> .</p> <p>A few things to note regarding this, when numerous definitions of the function are given, Haskell will execute it from top to bottom. Hence, if we are calling <code>sfz 0</code> it would always execute the first line and not the second. First Order Logic page 35</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">sumodd</span> <span class="ow">::</span> <span class="kt">Int</span> <span class="ow">-></span> <span class="kt">Int</span> </span></span><span class="line"><span class="cl"><span class="nf">sumodd</span> <span class="mi">0</span> <span class="ow">=</span> <span class="mi">0</span> </span></span><span class="line"><span class="cl"><span class="nf">sumodd</span> <span class="n">n</span> <span class="ow">=</span> <span class="p">(</span><span class="mi">2</span> <span class="o">*</span> <span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="n">sumodd</span> <span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> </span></span></code></pre></div><p>Using what you have learnt so far, try to identify what this syntax says.</p> <p>This can be interpreted in the same way as above. <code>sumodd</code> is a function that takes an <code>Int</code> and returns an <code>Int</code> . If given <code>0</code>, the function will return <code>0</code>, else for any other value <code>n</code> it will return the value <code>(2 * n - 1) + sumodd (n-1)</code> .</p> <p>FUN FACT! Both these are recursive functions, as the function is called within the function definition.</p> <p>( The same concept can be used to understand functions <code>ta</code> and <code>tb</code> defined later on in the same slide.)</p> <h3 id="function-composition">Function composition</h3> <p>Note that the notation <code>.</code> has been used in numerous exercises and past papers, this denotes composite functions. If we consider the example <code>f . g x</code> , this can be written mathematically as <code>f(g x)</code>. In other words <code>f . g</code> is a new function that takes the output of <code>g</code> and provides it as input to <code>f</code>. Let’s work through a simple example, consider the two functions:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">add1</span><span class="ow">::</span> <span class="kt">Int</span> <span class="ow">-></span> <span class="kt">Int</span> </span></span><span class="line"><span class="cl"><span class="nf">add1</span> <span class="n">x</span> <span class="ow">=</span> <span class="n">x</span><span class="o">+</span><span class="mi">1</span> </span></span><span class="line"><span class="cl"><span class="nf">multiply5</span><span class="ow">::</span> <span class="kt">Int</span> <span class="ow">-></span> <span class="kt">Int</span> </span></span><span class="line"><span class="cl"><span class="nf">multiply5</span> <span class="n">x</span> <span class="ow">=</span> <span class="mi">5</span><span class="o">*</span><span class="n">x</span> </span></span></code></pre></div><p>It is clear that the function <code>add1</code> adds one to the input, and the function <code>multiply5</code> multiplies the input by 5. Now if we consider <code>multiply5 . add1</code> this is a function that takes an int as input and returns an int as output. Hence if we run <code>multiply5 . add1 8</code> this is the same as computing <code>multiply5 (add1 8) = multiply5 (8+1) = multiply5 9 = 45</code> .</p> <p>Now moving on to the lectures on structural induction, here you come across the concepts of lists and trees. Let’s start off by understanding what these two data types are.</p> <h3 id="lists">Lists</h3> <p>Lists in Haskell are just like the lists you find in the real world. Any list in Haskell has a particular type, for instance, <code>[Int]</code> that denotes a list of <code>Int</code> s. Here all the elements must be of <code>Int</code> type. A list is written within <code>[]</code> where each term is separated by commas. For example, a list of 1,2,3 and 4 would look like <code>[1,2,3,4]</code> . And an empty list would be <code>[]</code> .</p> <p>This can be shown by:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kr">data</span> <span class="p">[</span> <span class="n">a</span> <span class="p">]</span> <span class="ow">=</span> <span class="kt">[]</span> <span class="o">|</span> <span class="n">a</span> <span class="kt">:</span> <span class="p">[</span> <span class="n">a</span> <span class="p">]</span> </span></span></code></pre></div><p>There are two main functions that are used with lists,</p> <p><code>:</code>, this takes in an element and a list and adds the element to the start of the list, example : <code>1 : [2,3,4] = [1,2,3,4]</code></p> <p><code>++</code> This takes two lists and returns a single list and concaternates them. Example: <code>[1,2,3] ++ [4] = [1,2,3,4]</code></p> <p>A list can be defined either as an empty list denoted by <code>[]</code> or as an element added onto another list (empty or not) which can be represented as <code>x:xs</code> , where <code>x</code> denotes the first element and <code>xs</code> denotes the rest of the list.</p> <p>In other words, any list that is not empty can be represented in the form <code>x:xs</code> . For example a list of one element can be denoted in the above notation as <code>x:[]</code> , where <code>x</code> takes the value of the element. A list of two elements can be written as an element added onto a list which already has an element <code>x:y:[]</code> which is the same as <code>[x,y]</code> , where <code>x</code> denotes the first element of the list and <code>y</code> denotes the second. Using this concept a list with numbers 1 to 5 can be represented as <code>1:[2,3,4,5]</code> .</p> <p>Using this, let’s try to understand the standard functions in page 6 of the structural induction slides</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">length</span> <span class="kt">[]</span> <span class="ow">=</span> <span class="mi">0</span> <span class="c1">-- ( L1 )</span> </span></span><span class="line"><span class="cl"><span class="nf">length</span> <span class="p">(</span> <span class="n">x</span> <span class="kt">:</span> <span class="n">xs</span> <span class="p">)</span> <span class="ow">=</span> <span class="mi">1</span> <span class="o">+</span> <span class="n">length</span> <span class="n">xs</span> <span class="c1">-- ( L2 )</span> </span></span></code></pre></div><p>We can convert this to a mathematical function, since we have multiple lines defining the function this would map to a piecewise function bellow:</p> <p>function</p> <p>In other words, what this says is if the list is empty then the length of the list is zero. If that’s not the case we learnt above that any non-empty list can be represented in the form of an element concatenated onto another list hence we can write the list as <code>x:xs</code> . If that is the case then the length of the list is 1+ the length of rest of the list <code>xs</code> .</p> <p>Feel free to skip to the next function if you understood what happens in the above function, but let me show how this function works with an example, lets say we want to calculate the length of the list <code>[1,2]</code> .</p> <p>When we call <code>length [1,2]</code> , Haskell first checks if it is of the form <code>length []</code> which it is not because the list is not empty. So it then tries to see whether it is of the form <code>length x:xs</code> , where <code>x</code> is 1 and <code>xs</code> is <code>[2]</code> (pattern matching). As this is the case, <code>length [1,2]</code> becomes <code>1+ length [2]</code> then repeating the above process, we know the list is not yet empty, so it takes the form <code>x:xs</code> where <code>x=2</code> and <code>xs = []</code> because of this <code>1+ length [2]</code> becomes <code>1 + 1 + length []</code> now when <code>length []</code> is called Haskell identifies that the list is empty and returns 0, putting it all together we get:</p> <p><code>length [1,2] = 1+ length[2] = 1+ 1 + length [] = 1+ 1+ 0</code></p> <p>which is then evaluated to 2, which we know is correct as <code>[1,2]</code> is a list with two elements.</p> <p>The same concept is used whenever coding with lists, first the function is defined for an empty list, and then for a list with one or more elements.</p> <p>Looking at the other functions defined on the same page:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="nf">map</span> <span class="n">f</span> <span class="kt">[]</span> <span class="ow">=</span> <span class="kt">[]</span> <span class="c1">-- ( M1 )</span> </span></span><span class="line"><span class="cl"><span class="nf">map</span> <span class="n">f</span> <span class="p">(</span> <span class="n">x</span> <span class="kt">:</span> <span class="n">xs</span> <span class="p">)</span> <span class="ow">=</span> <span class="n">f</span> <span class="n">x</span> <span class="kt">:</span> <span class="n">map</span> <span class="n">f</span> <span class="n">xs</span> <span class="c1">-- ( M2 )</span> </span></span></code></pre></div><p>The code above defines function <code>map</code> which takes in a function and a list as inputs. Conceptually map applies the function <code>f</code> to all the elements of the input list. Similar to the above instance, we start off by defining this for an empty list, which would return an empty list, as there are no elements to apply the function to. Then the function is defined for the case when the list is not empty, what the second line of the code is saying is if a function <code>f</code> and a list <code>x:xs</code> are given to the function map, then we apply the function <code>f</code> to <code>x</code> and continue applying the function <code>f</code> to the rest of the list by calling the function with the same input function and the rest of the list.</p> <p>Let’s see how the above code would work by looking at how <code>map (*2) [1,2]</code> would run:</p> <p><code>map (*2) [1,2] = (*2) 1 : map [2] = (*2) 1 : (*2) 2 : [] = 2:4:[] = [2,4]</code></p> <p>because the input function was <code>*2</code> (multiplication by two) each step will apply <code>*2</code> to the first element of the list till the list is empty.</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="kt">[]</span> <span class="o">++</span> <span class="n">ys</span> <span class="ow">=</span> <span class="n">ys</span> <span class="c1">-- ( A1 )</span> </span></span><span class="line"><span class="cl"><span class="p">(</span> <span class="n">x</span> <span class="kt">:</span> <span class="n">xs</span> <span class="p">)</span> <span class="o">++</span> <span class="n">ys</span> <span class="ow">=</span> <span class="n">x</span> <span class="kt">:</span> <span class="p">(</span> <span class="n">xs</span> <span class="o">++</span> <span class="n">ys</span> <span class="p">)</span> <span class="c1">-- ( A2 )</span> </span></span></code></pre></div><p>Here the function <code>++</code> is defined, note how it is written in between two inputs, this is called infix notation please feel free to interpret the above as:</p> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-haskell" data-lang="haskell"><span class="line"><span class="cl"><span class="p">(</span><span class="o">++</span><span class="p">)</span> <span class="kt">[]</span> <span class="n">ys</span> <span class="ow">=</span> <span class="n">ys</span> <span class="c1">-- ( A1 )</span> </span></span><span class="line"><span class="cl"><span class="p">(</span><span class="o">++</span><span class="p">)</span> <span class="p">(</span> <span class="n">x</span> <span class="kt">:</span> <span class="n">xs</span> <span class="p">)</span> <span class="n">ys</span> <span class="ow">=</span> <span class="n">x</span> <span class="kt">:</span> <span class="p">(</span><span class="o">++</span><span class="p">)</span> <span class="n">xs</span> <span class="n">ys</span> <span class="c1">-- ( A2 )</span> </span></span></code></pre></div><p>Using what you’ve learnt above, try to understand the above function on your own before reading the explanation below. I’ll give you a hint to help, the function takes two lists as input.</p> <p>So the above two lines of code can be interpreted as as :</p> <p>If the first list is empty then the output is just the second list If not then the output is the first element of the first list added onto the result of <code>(++) xs ys</code></p> <p>Conceptually the above function will concaternate the first list passed as an argument to the second list. The breakdown of how the output for <code>(++) [1,2,3] [4,5,6]</code> is generated is below:</p> <p><code>(++) [1,2,3] [4,5,6] = 1: (++) [2,3] [4,5,6]= 1:2: (++) [3] [4,5,6] = 1:2:3:(++) [] [4,5,6] = 1:2:3:[4,5,6] = [1,2,3,4,5,6]</code></p> </article> <article> <h1>Microsoft Certified: Azure Data Fundamentals (DP-900)</h1> <p>Mon, 15 Jan 2024 00:00:00 +0000</p> <h2 id="overview">Overview</h2> <p>I completed the <strong>Azure Data Fundamentals (DP-900)</strong> certification to solidify my understanding of cloud data services. This certification validates foundational knowledge of core data concepts, including relational and non-relational data, and how to work with them within the Microsoft Azure ecosystem.</p> <h3 id="skills-verified">Skills Verified</h3> <ul> <li>Describing core data concepts and data workloads.</li> <li>Identifying considerations for relational and non-relational data on Azure.</li> </ul> <p> <em>(Replace this # link with your actual Microsoft Learn badge URL!)</em></p> </article> <article> <h1>Experience</h1> <p>Tue, 24 Oct 2023 00:00:00 +0000</p> </article> <article> <h1>PENDING: Conference paper for the All-Actuaries summit</h1> <p>Mon, 01 Jan 0001 00:00:00 +0000</p> <div class="callout flex px-4 py-3 mb-6 rounded-md border-l-4 bg-blue-100 dark:bg-blue-900 border-blue-500" data-callout="note" data-callout-metadata=""> <span class="callout-icon pr-3 pt-1 text-blue-600 dark:text-blue-300"> <svg height="24" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="m16.862 4.487l1.687-1.688a1.875 1.875 0 1 1 2.652 2.652L6.832 19.82a4.5 4.5 0 0 1-1.897 1.13l-2.685.8l.8-2.685a4.5 4.5 0 0 1 1.13-1.897zm0 0L19.5 7.125"/></svg> </span> <div class="callout-content dark:text-neutral-300"> <div class="callout-title font-semibold mb-1">Note</div> <div class="callout-body"><p>Click the <em>Cite</em> button above to demo the feature to enable visitors to import publication metadata into their reference management software.</p></div> </div> </div> <div class="callout flex px-4 py-3 mb-6 rounded-md border-l-4 bg-blue-100 dark:bg-blue-900 border-blue-500" data-callout="note" data-callout-metadata=""> <span class="callout-icon pr-3 pt-1 text-blue-600 dark:text-blue-300"> <svg height="24" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="m16.862 4.487l1.687-1.688a1.875 1.875 0 1 1 2.652 2.652L6.832 19.82a4.5 4.5 0 0 1-1.897 1.13l-2.685.8l.8-2.685a4.5 4.5 0 0 1 1.13-1.897zm0 0L19.5 7.125"/></svg> </span> <div class="callout-content dark:text-neutral-300"> <div class="callout-title font-semibold mb-1">Note</div> <div class="callout-body"><p>Create your slides in Markdown - click the <em>Slides</em> button to check out the example.</p></div> </div> </div> <p>Add the publication’s <strong>full text</strong> or <strong>supplementary notes</strong> here. You can use rich formatting such as including .</p> </article> <article> <h1>Personal Projects</h1> <p>Mon, 01 Jan 0001 00:00:00 +0000</p> </article> <article> <h1>Talks & Presentations</h1> <p>Mon, 01 Jan 0001 00:00:00 +0000</p> </article> </main></body></html>