<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>lambda calculus on Matthias Preu</title>
    <link>https://www.matthiaspreu.com/tags/lambda-calculus/</link>
    <description>Recent content in lambda calculus on Matthias Preu</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.</copyright>
    <lastBuildDate>Thu, 13 Feb 2020 23:14:47 +0100</lastBuildDate>
    
	<atom:link href="https://www.matthiaspreu.com/tags/lambda-calculus/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>Lambda Calculus - Recursion</title>
      <link>https://www.matthiaspreu.com/posts/lambda-calculus-recursion/</link>
      <pubDate>Thu, 13 Feb 2020 23:14:47 +0100</pubDate>
      
      <guid>https://www.matthiaspreu.com/posts/lambda-calculus-recursion/</guid>
      <description>&lt;p&gt;In computer science &lt;em&gt;recursion&lt;/em&gt; is the act of solving a problem with intermediate results of smaller instances of the same problem. A function used to solve a problem is therefore calling itself within its own definition. This concept is usually supported by most programming languages in addition to the &lt;em&gt;imperative&lt;/em&gt; style of programming, which uses control structures such as &lt;em&gt;for&lt;/em&gt; and &lt;em&gt;while&lt;/em&gt; loops. Some functional programming languages even support &lt;em&gt;recursion&lt;/em&gt; as the only method of problem solving. This article is about the definition of recursion in lambda calculus.&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>Lambda Calculus - Boolean Algebra</title>
      <link>https://www.matthiaspreu.com/posts/lambda-calculus-boolean-algebra/</link>
      <pubDate>Sat, 08 Feb 2020 17:33:23 +0100</pubDate>
      
      <guid>https://www.matthiaspreu.com/posts/lambda-calculus-boolean-algebra/</guid>
      <description>&lt;p&gt;After introducing fundamentals of the lambda calculus in a &lt;a href=&#34;https://www.matthiaspreu.com/posts/lambda-calculus-fundamentals/&#34;&gt;previous article&lt;/a&gt;, along with demonstrations how it can be used for basic arithmetic, the following text has the goal to show how Boolean algebra is expressed in this formal system. Based on the definitions of &lt;em&gt;true&lt;/em&gt; and &lt;em&gt;false&lt;/em&gt; further basic operations of Boolean algebra can be derived, which then leads to one important aspect in programming: expressing &lt;em&gt;conditionals&lt;/em&gt;.&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>Fundamentals of Lambda Calculus</title>
      <link>https://www.matthiaspreu.com/posts/lambda-calculus-fundamentals/</link>
      <pubDate>Mon, 03 Feb 2020 21:35:18 +0100</pubDate>
      
      <guid>https://www.matthiaspreu.com/posts/lambda-calculus-fundamentals/</guid>
      <description>Lambda calculus is a formal system to study computable functions based on variable binding and substitution. Introduced in the 1930s by Alonzo Church, it is (in its typed form) the fundamental concept of functional programming languages like Haskell and Scala. Although the topic might seem very theoretical, some basic knowledge in lambda calculus can be very helpful to understand these languages, and where they originated from, much better. The goal of this article is to introduce some basic concepts of lambda calculus, which later on can be mapped to real world usage scenarios with functional programming languages.</description>
    </item>
    
  </channel>
</rss>