The Compiler Won't Let You Burn Yourself

The lye calculator on the soapmaking forum won’t let me proceed without entering every oil separately. Not by weight — by oil type. 454 grams of olive oil has a different saponification value than 454 grams of coconut oil. Mix them up and you get either caustic soap that burns skin or greasy soap that never sets. The calculator refuses to add grams of olive to grams of coconut until they’ve each been multiplied by their respective SAP values and converted to grams-of-lye-required.

This is dimensional analysis enforced by UI. Phantom types enforce it at compile time.

The idea appeared in Haskell papers in the late ’90s: attach a type parameter that carries no runtime data but restricts what operations are valid. Two values might both be Double underneath, but if one is tagged Grams Olive and another Grams Coconut, the compiler won’t let you add them directly.

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

newtype Mass oil = Mass Double deriving (Show, Num)
data Olive; data Coconut

sapValue :: Mass Olive -> Double
sapValue (Mass g) = g * 0.134  -- NaOH grams needed

oliveLye :: Mass Olive -> Double
oliveLye a = sapValue a

-- sapValue (Mass 454 :: Mass Coconut)  -- Won't compile!

The sapValue function only accepts Mass Olive. Pass it Mass Coconut and GHC refuses. The phantom parameter — Olive or Coconut — exists purely in the type system; at runtime it’s all just doubles.

Rust achieves the same effect with PhantomData:

use std::marker::PhantomData;

struct Mass<Oil>(f64, PhantomData<Oil>);
struct Olive;
struct Coconut;

impl Mass<Olive> {
    fn sap_value(&self) -> f64 { self.0 * 0.134 }
}

fn main() {
    let olive = Mass::<Olive>(454.0, PhantomData);
    println!("NaOH needed: {:.1}g", olive.sap_value());
    // Mass::<Coconut>(454.0, PhantomData).sap_value(); // error!
}

Output:

NaOH needed: 60.8g

The forum calculator caught my mistake when I entered coconut oil twice under different names. The type system would have caught it earlier — before I ordered supplies, before I mixed anything, before the batch went wrong.

Phantom types cost nothing at runtime. The tag compiles away entirely. What remains is the guarantee that you computed lye requirements for the oils you actually have, not the oils you thought you had.

My first batch is curing in the garage. Six weeks before I know if the ratios were right. The calculator said yes. The types would have agreed.