Introduction to Functional Programming with Typescript
Tags: functional, javascript, typescript, lambda
Published: 2021-01-15 21:14:43

---
title: Introduction to Functional Programming with Typescript
published: true
description: Using Typescript to give an introduction to understanding functional programming, lambda calculus and how function composition works. 
tags: functional, javascript, typescript, lambda
//cover_image:
---
###This is the beginning of a series of short guides on functional programming, much of what I've posted on reddit, I'm compiling for dev.to.

------

I finally went back to try and learn functional programming, and realized that the type structure of the function composition is in itself data! My old friend Zac tried to teach me this many years ago, et voila. This helped me better understand currying and higher order functions. For example:

    const K  = a => b => a;   
    const KI = a => b => b; 

`K` is technically a Kestrel combinator or first function or constant function. `KI` is a Kite combinator or second function. You can copy and paste these into the console (F12) and test it out.

    K(1)(0)  // ->  1
    KI(1)(0) // ->  0

I think Typescript actually helps us here to make sense of what we're going to do next so let's create a type association.

    const T = K 
    const F = KI
    
    // pretend we're in a .ts file  
    type BOOL = T | F; 

So `BOOL` simply says it's either `T` or `F` (true or false) like any basic Boolean.

Keep in mind that `T` and `F` are still just functions `K` and `KI`

So we can create an `AND` function that takes `T` and `T` and returns True; or `F` and `T` and returns False. This `AND` function will look a bit weird but bare with me.

    const AND = p => q => p(q)(p);   

We pass in a function to parameter `p` and curry another argument (function) to parameter `q` so that `p(q)(p)` will return us a function of p. These are higher order functions or curried functions that we define and expect to pass around in our program. This is just a discipline to writing programs and comes from lambda calculus. Immediately this will probably seem very odd, and I'll try to break it down.

`AND(T)` gives us `q => p(q)(p)`, or essentially `q => T(q)(T)`. Well we know `T` returns whatever it's first argument is`(a => b => a)`. So if `q` is `F` it will be `F`.

We can satisfy parameter `q` with argument `F`. `AND(T)(F)` or `T(F)(T)`. We're not calling `F` but passing it in. Now this means we satisfy every functional parameter for `T`.

Essentially `AND(T)(F)` becomes `T(F)(T)` but what's different is `AND` sets up the second parameter as first argument in `T`. You can run `T(T)(F)` in the console and get `a => b => a`.  `T(F)(T)` is `a => b => b` .. imagine `AND(T)(F)` as `T => F => T(F)(T)`.

If this doesn't immediately make sense that's ok (I'm trying my best 😅). We can simply run it in the browser instead!

    AND(T)(T)  // -> a => b => a 
    AND(T)(F)  // -> a => b => b 
    AND(F)(T)  // -> a => b => b 
    AND(F)(F)  // -> a => b => b   

The resulting value from `AND(T)(T)` *is* the function composition we passed in, `T`! So the type association of `a => b => a`  as we've already defined in our program (or console in this case) is `typeof T` in `type BOOL`.

```ts
// main.ts
// Compiles! ✅
const K = a => b => a;
const KI = a => b => b;

type TRUE = typeof K;
type FALSE = typeof KI;

type BOOL = TRUE | FALSE;

const AND: BOOL = p => q => p(q)(p);

(async (): Promise<FALSE> => {
    const falsey: BOOL = AND(K)(KI);
    return falsey;
})();

```

Now you're more likely to see pure FO in other languages like lisp, clojure or haskell so if this scares you, don't worry! There's a reason C# is OO and F# is FO, trying to write FO in something like typescript is cumbersome without default lazy loaded lists etc.
I think running it in the browser first hand (in js) is a great way to learn how the composition of functions itself can be treated as data. 

I find this fascinating. There's definitely a better explanation out there but this is how I came to understand it after finally revisiting it.  That euphoric feeling of when something clicks after many months of attempts to understand something is the best and never gets old!

------

Next: How to compose a NOT function -- ⏭⌛