You Can't Uncurdle Milk: Linear Types

Cheese making has a one-way quality. Once you’ve added rennet and the milk has set into curds, you can’t shake it back into liquid. Once you’ve pressed those curds into a wheel, you can’t unpressed them. The kitchen enforces this physically—entropy, denatured proteins, broken emulsions.

Linear types enforce the same constraint in code: a value can be used exactly once. After you consume it, the compiler won’t let you reference it again. This maps perfectly to irreversible transformations.

In Rust, ownership and moves give you affine types (use-at-most-once), which is close enough:

struct Milk { temp_c: f32 }
struct Curds { ph: f32 }

fn add_rennet(milk: Milk) -> Curds {
    Curds { ph: 6.4 }
}

let milk = Milk { temp_c: 32.0 };
let curds = add_rennet(milk);
// milk is gone now—can't use it again

Trying to reference milk after the call gives a compile error. The transformation consumed it.

Haskell added linear types in GHC 9.0. The %1 arrow means the argument must be used exactly once:

{-# LANGUAGE LinearTypes #-}

data Milk = Milk
data Curds = Curds { ph :: Float }

addRennet :: Milk %1 -> Curds
addRennet Milk = Curds 6.4

main = do
  let curds = addRennet Milk
  print "Curds formed"

The %1 annotation prevents accidentally reusing the milk value elsewhere in the function. It’s a stronger guarantee than Rust’s affine version, though both prevent the same mistake: treating an irreversible transformation as if it were reversible.

The type system becomes a model of physical reality. You can’t take back what the rennet did. The compiler knows this.