Why Types Matter

post · September 3, 2024

Lorem ipsum dolor sit amet, consectetur adipiscing elit¹. Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Nullam id dolor id nibh ultricies vehicula ut id elit. Maecenas sed diam eget risus varius blandit sit amet non magna.

Cras mattis consectetur purus sit amet fermentum². Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor. Aenean lacinia bibendum nulla sed consectetur.

1. The Compiler Is Your Friend

Donec ullamcorper nulla non metus auctor fringilla. Maecenas faucibus mollis interdum. Nulla vitae elit libero, a pharetra augue. Cras mattis consectetur purus sit amet fermentum.

Sed posuere consectetur est at lobortis. Vestibulum id ligula porta felis euismod semper. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.

1
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
2

3
function divide(a: number, b: number): Result<number, string> {
4
  if (b === 0) return { ok: false, error: "Division by zero" };
5
  return { ok: true, value: a / b };
6
}

Aenean lacinia bibendum nulla sed consectetur. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor. Morbi leo risus, porta ac consectetur ac, vestibulum at eros. Etiam porta sem malesuada magna mollis euismod.

Donec id elit non mi porta gravida at eget metus. Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Nullam quis risus eget urna mollis ornare vel eu leo.

2. Algebraic Data Types

Morbi leo risus, porta ac consectetur ac, vestibulum at eros³. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa justo sit amet risus.

Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Donec sed odio dui. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.

1
enum Shape {
2
    Circle(f64),
3
    Rectangle(f64, f64),
4
    Triangle(f64, f64, f64),
5
}
6

7
fn area(shape: &Shape) -> f64 {
8
    match shape {
9
        Shape::Circle(r) => std::f64::consts::PI * r * r,
10
        Shape::Rectangle(w, h) => w * h,
11
        Shape::Triangle(a, b, c) => {
12
            let s = (a + b + c) / 2.0;
13
            (s * (s - a) * (s - b) * (s - c)).sqrt()
14
        }
15
    }
16
}

Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem nec elit. Cras justo odio, dapibus ut facilisis in, egestas eget quam. Nulla vitae elit libero, a pharetra augue.

Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Maecenas faucibus mollis interdum. Sed posuere consectetur est at lobortis. Aenean lacinia bibendum nulla sed consectetur.

2.1. Sum Types vs Product Types

Vestibulum id ligula porta felis euismod semper. Donec ullamcorper nulla non metus auctor fringilla. Cras mattis consectetur purus sit amet fermentum. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor.

Nullam id dolor id nibh ultricies vehicula ut id elit. Maecenas sed diam eget risus varius blandit sit amet non magna. Etiam porta sem malesuada magna mollis euismod. Morbi leo risus, porta ac consectetur ac, vestibulum at eros.

Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa justo sit amet risus. Donec id elit non mi porta gravida at eget metus.

3. Generics and Polymorphism

Aenean eu leo quam. Pellentesque ornare sem lacinia quam venenatis vestibulum. Sed posuere consectetur est at lobortis. Praesent commodo cursus magna, vel scelerisque nisl consectetur et.

Donec sed odio dui. Cras justo odio, dapibus ut facilisis in, egestas eget quam. Nullam quis risus eget urna mollis ornare vel eu leo. Nulla vitae elit libero, a pharetra augue.

1
function pipe<A, B, C>(
2
  value: A,
3
  fn1: (a: A) => B,
4
  fn2: (b: B) => C
5
): C {
6
  return fn2(fn1(value));
7
}
8

9
const result = pipe(
10
  "hello",
11
  (s) => s.length,
12
  (n) => n > 3
13
);
14
// result: true

Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Cras mattis consectetur purus sit amet fermentum. Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem nec elit.

Maecenas faucibus mollis interdum. Vestibulum id ligula porta felis euismod semper. Donec ullamcorper nulla non metus auctor fringilla. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor.

4. Type Narrowing

Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec id elit non mi porta gravida at eget metus. Aenean eu leo quam. Pellentesque ornare sem lacinia quam venenatis vestibulum.

1
function processValue(value: string | number) {
2
  if (typeof value === "string") {
3
    // TypeScript knows value is string here
4
    return value.toUpperCase();
5
  }
6
  // TypeScript knows value is number here
7
  return value.toFixed(2);
8
}

Sed posuere consectetur est at lobortis. Aenean lacinia bibendum nulla sed consectetur. Morbi leo risus, porta ac consectetur ac, vestibulum at eros. Maecenas sed diam eget risus varius blandit sit amet non magna.

Etiam porta sem malesuada magna mollis euismod. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa justo sit amet risus. Nullam id dolor id nibh ultricies vehicula ut id elit.

4.1. Discriminated Unions

Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Donec sed odio dui. Cras justo odio, dapibus ut facilisis in, egestas eget quam. Nulla vitae elit libero, a pharetra augue.

Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem nec elit. Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Cras mattis consectetur purus sit amet fermentum.

Maecenas faucibus mollis interdum. Donec ullamcorper nulla non metus auctor fringilla. Vestibulum id ligula porta felis euismod semper. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor.

5. Phantom Types

Nullam quis risus eget urna mollis ornare vel eu leo. Aenean lacinia bibendum nulla sed consectetur. Sed posuere consectetur est at lobortis. Morbi leo risus, porta ac consectetur ac, vestibulum at eros.

1
use std::marker::PhantomData;
2

3
struct Locked;
4
struct Unlocked;
5

6
struct Door<State> {
7
    _state: PhantomData<State>,
8
}
9

10
impl Door<Locked> {
11
    fn unlock(self) -> Door<Unlocked> {
12
        Door { _state: PhantomData }
13
    }
14
}
15

16
impl Door<Unlocked> {
17
    fn lock(self) -> Door<Locked> {
18
        Door { _state: PhantomData }
19
    }
20

21
    fn open(&self) {
22
        println!("Door is open!");
23
    }
24
}

Maecenas sed diam eget risus varius blandit sit amet non magna. Etiam porta sem malesuada magna mollis euismod. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa justo sit amet risus.

6. Conclusion

Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Donec sed odio dui. Cras justo odio, dapibus ut facilisis in, egestas eget quam. Nullam quis risus eget urna mollis ornare vel eu leo.

Nulla vitae elit libero, a pharetra augue. Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Cras mattis consectetur purus sit amet fermentum. Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem nec elit.

This is a sidenote about static typing and its origins in the ML family of languages. ↩
See Hoare’s 2009 paper “Null References: The Billion Dollar Mistake” for more on this topic. ↩
Algebraic data types were first introduced in Hope (1980) and later refined in Standard ML and Haskell. The key insight is that types form an algebra: sum types (tagged unions) correspond to addition, product types (tuples, records) correspond to multiplication, and function types correspond to exponentiation. This algebraic structure gives us powerful reasoning tools — for instance, the number of inhabitants of a type can be computed using these operations, which helps verify exhaustiveness of pattern matching and detect dead code at compile time. ↩