Recipe Formatter —
One Call,
Six Kinds of Quantity.

Glossary

A 30-Second Experiment: Watch the Registry Work

One generic function, one registered branch (int), one fallback. Predict each result before pressing Run — especially the second one.

from functools import singledispatch

@singledispatch
def show(x):
    return "object branch"

@show.register
def _(x: int):
    return "int branch"

print(show(1), "|", show(True), "|", show("hi"))
print(show.dispatch(bool) is show.dispatch(int))
print(show.dispatch(str) is show.dispatch(object))
print(sorted(t.__name__ for t in show.registry))

Error Message Decoder

You will meet these while experimenting. Each points at a specific dispatch mistake. The first two are exact messages from Python.

The Four Flavors, Applied to Quantities

What singledispatch Can and Cannot Do

We start with the ladder, watch it fail on a type it never heard of, then rebuild the same feature as a generic function. This is the smallest complete example of single dispatch: a fallback plus three registered branches.

from fractions import Fraction
from functools import singledispatch

def format_ladder(value):
    if isinstance(value, int):
        return str(value)
    elif isinstance(value, float):
        return f"{value:.2f}".rstrip("0").rstrip(".")
    elif isinstance(value, str):
        return value
    raise TypeError(f"No format rule for {type(value).__name__}")

try:
    format_ladder(Fraction(3, 2))
except TypeError as err:
    print("Ladder failed:", err)

print("-" * 40)

@singledispatch
def format_quantity(value):
    return f"?? {value!r}"

@format_quantity.register
def _(value: int):
    return str(value)

@format_quantity.register
def _(value: float):
    return f"{value:.2f}".rstrip("0").rstrip(".")

@format_quantity.register
def _(value: str):
    return value

for item in [2, 0.5, 1.25, 3.0, "a pinch", Fraction(3, 2)]:
    print(f"{type(item).__name__:<9} → {format_quantity(item)}")

🔍 Deep dive — how one call finds its function

Follow format_quantity(0.5). The decorator replaced the name format_quantity with a small dispatcher object. Every call goes through it:

📖 Line-by-line walkthrough

1. from fractions import Fraction — only used here to create a type the ladder has never seen. It returns in Program 2 as a first-class citizen.
2. from functools import singledispatch — the decorator that turns an ordinary function into a generic function.
3. format_ladder, the int branch — isinstance(value, int) asks "are you an integer?" and returns the digits as text.
4. The float branch and the rstrip trick — f"{value:.2f}" gives two decimals ("0.50", "3.00"); rstrip("0") removes trailing zeros ("0.5", "3."); rstrip(".") removes a leftover dot ("3"). It is safe only because .2f always contains a dot, which stops the first rstrip.
5. The str branch and the final raise — strings like "a pinch" pass through untouched; anything else raises TypeError naming the offending type.
6. The first try / except — Fraction(3, 2) matches none of the three branches, so the ladder raises and we print the message. This is the failure we are about to design away.
7. print("-" * 40) — a divider. Here * repeats a string (itself a small piece of polymorphism).
8. @singledispatch def format_quantity(value) — the undecorated body is the fallback, registered for object. {value!r} uses repr, so Fraction(3, 2) shows its type clearly.
9. @format_quantity.register with def _(value: int) — the bare decorator reads the annotation of the first parameter to learn which type this function is for. The function is named _ because its name is never used again; the registry holds it.
10. The float and str registrations — the same pattern; the float body is exactly the ladder's float branch, now in its own function.
11. The final loop — f"{type(item).__name__:<9}" left-aligns the type name in a 9-character column. Notice that 3.0 prints as 3 and 2 as 2.
12. The last item, Fraction(3, 2) — no branch exists, so the fallback answers with ?? Fraction(3, 2). No crash, no edits to existing code — and Program 2 fixes it by registering one new function.

⚠️ Common mistakes

🧪 Try it yourself

Cooks write 1 1/2, not 1.5 or 3/2. This program registers Fraction, turns any fraction into a mixed number, and teaches the float branch to snap messy decimals like 0.333 to the nearest kitchen fraction.

from fractions import Fraction
from functools import singledispatch

def to_mixed(frac):
    whole, rem = divmod(frac.numerator, frac.denominator)
    if rem == 0:
        return str(whole)
    if whole == 0:
        return f"{rem}/{frac.denominator}"
    return f"{whole} {rem}/{frac.denominator}"

@singledispatch
def format_quantity(value):
    return f"?? {value!r}"

@format_quantity.register
def _(value: int):
    return str(value)

@format_quantity.register
def _(value: Fraction):
    return to_mixed(value)

@format_quantity.register
def _(value: float):
    return to_mixed(Fraction(value).limit_denominator(8))

for item in [2, Fraction(3, 2), Fraction(1, 3), Fraction(4, 2), Fraction(7, 4), 0.75, 2.5, 0.333, 0.1, 1.9]:
    print(f"{item!r:<14} → {format_quantity(item)}")

print(Fraction(0.1))
print(Fraction("0.1"))
print(Fraction(0.1).limit_denominator(8))

🔍 Deep dive — mixed numbers and why floats need rounding

divmod(a, b) returns the quotient and remainder together. For Fraction(7, 4), that is divmod(7, 4) = (1, 3): one whole and three quarters left over.

📖 Line-by-line walkthrough

1. to_mixed(frac) — a plain helper (not dispatched). Both the Fraction and float branches reuse it, so mixed-number logic exists exactly once.
2. whole, rem = divmod(frac.numerator, frac.denominator) — splits the top and bottom into whole units and a leftover numerator. Tuple unpacking assigns both at once.
3. if rem == 0: return str(whole) — an exact whole number such as 2/1; print only the whole part.
4. if whole == 0 — a proper fraction such as 1/3; print only the fraction.
5. The last return — both parts exist: "1 1/2", with a space between the whole and fraction as in a cookbook.
6. The fallback and int branch — unchanged from Program 1. Programs build on each other; the generic function only grows.
7. register for Fraction — one line: delegate to to_mixed. This is the whole cost of supporting a new type.
8. register for float — converts the float to a Fraction, snaps it with limit_denominator(8), then reuses to_mixed. Note the float branch now delegates instead of formatting decimals itself.
9. The loop with {item!r:<14} — !r prints the repr (so you see Fraction(3, 2) and not just 3/2), and :<14 pads it so the arrows line up.
10. print(Fraction(0.1)) — the huge numerator and denominator: the exact value of the float.
11. print(Fraction("0.1")) — from a string, Python reads decimal digits exactly: 1/10.
12. Fraction(0.1).limit_denominator(8) — shrinks the huge fraction to the nearest allowed one: 1/8.

⚠️ Common mistakes

🧪 Try it yourself

Now the generic function covers all six branches: int, Fraction, float, str, a custom Money class, and tuple for ranges like 2–3. The tuple branch calls format_quantity again on each end of the range — dispatch inside dispatch.

from fractions import Fraction
from functools import singledispatch

class Money:
    def __init__(self, amount):
        self.amount = round(amount, 2)

    def __str__(self):
        return f"PHP {self.amount:,.2f}"

    def __repr__(self):
        return f"Money({self.amount})"

def to_mixed(frac):
    whole, rem = divmod(frac.numerator, frac.denominator)
    if rem == 0:
        return str(whole)
    if whole == 0:
        return f"{rem}/{frac.denominator}"
    return f"{whole} {rem}/{frac.denominator}"

@singledispatch
def format_quantity(value):
    return f"?? {value!r}"

@format_quantity.register
def _(value: int):
    return str(value)

@format_quantity.register
def _(value: Fraction):
    return to_mixed(value)

@format_quantity.register
def _(value: float):
    return to_mixed(Fraction(value).limit_denominator(8))

@format_quantity.register
def _(value: str):
    return value

@format_quantity.register
def _(value: Money):
    return str(value)

@format_quantity.register
def _(value: tuple):
    low, high = value
    return f"{format_quantity(low)}–{format_quantity(high)}"

rows = [
    ("flour", 2, "cups"),
    ("milk", Fraction(3, 2), "cups"),
    ("vanilla", 0.5, "tsp"),
    ("salt", "a pinch", ""),
    ("butter", (2, 3), "tbsp"),
    ("saffron", Money(250), "per gram"),
    ("nutmeg", (Fraction(1, 4), "a pinch"), "tsp"),
]
for name, qty, unit in rows:
    print(f"{name:<8} {format_quantity(qty):>12} {unit}")

print(sorted(t.__name__ for t in format_quantity.registry))
print(format_quantity(Money(1234.5)))

🔍 Deep dive — six branches, one call site

📖 Line-by-line walkthrough

1. class Money and round(amount, 2) — a tiny value class that stores two decimal places. (Production money code uses decimal.Decimal; floats keep this lesson short.)
2. __str__ with {self.amount:,.2f} — the , adds thousands separators and .2f forces two decimals, so 250 prints as PHP 250.00.
3. __repr__ — the developer view, used by the fallback's !r when a type is unregistered. Always define it.
4. to_mixed and the first four registrations — carried over from Programs 1 and 2 exactly as they were.
5. register for str — returns the string untouched, so "a pinch" works as a quantity.
6. register for Money — the annotation value: Money works with your own classes just as it does with built-ins.
7. register for tuple and low, high = value — unpacks a two-element range. A one- or three-element tuple would raise ValueError here; Program 5 shows a more forgiving version.
8. f"{format_quantity(low)}–{format_quantity(high)}" — the recursive step. The inner calls go back through the dispatcher.
9. The rows list — each row is (name, quantity, unit). The quantities are seven different shapes in one list, sharing one for loop.
10. {format_quantity(qty):>12} — right-aligns the formatted quantity in a 12-character column so the numbers line up like a menu.
11. sorted(t.__name__ for t in format_quantity.registry) — reads the dispatcher's own registry: seven keys including object, the fallback.
12. format_quantity(Money(1234.5)) — a final direct call showing the thousands separator.

⚠️ Common mistakes

🧪 Try it yourself

Single dispatch has rules, and knowing them prevents the most confusing bugs. This program uses a tiny kind() function that just reports which branch ran, registers types in five stages, and prints the same seven samples after each stage so you can watch the answers change.

from collections.abc import Iterable, Sized
from decimal import Decimal
from fractions import Fraction
from functools import singledispatch
from numbers import Real

@singledispatch
def kind(value):
    return "fallback"

@kind.register
def _(value: int):
    return "int"

samples = [1, True, 2.5, Fraction(1, 2), Decimal("1.5"), "x", None]

def show(label):
    print(f"{label:<22}", [kind(s) for s in samples])

show("1. only int:")

@kind.register
def _(value: bool):
    return "bool"

show("2. + bool:")

@kind.register(Real)
def _(value):
    return "Real"

show("3. + Real (ABC):")

@kind.register
def _(value: str | bytes):
    return "text"

@kind.register(type(None))
def _(value):
    return "none"

show("4. + str|bytes, None:")

@kind.register(Decimal)
def _(value):
    return "Decimal"

show("5. + Decimal:")

print([t.__name__ for t in kind.registry])
print(kind.dispatch(Fraction) is kind.dispatch(float))

class Both:
    def __len__(self):
        return 0

    def __iter__(self):
        return iter(())

@singledispatch
def probe(x):
    return "fallback"

@probe.register(Sized)
def _(x):
    return "sized"

@probe.register(Iterable)
def _(x):
    return "iterable"

try:
    probe(Both())
except RuntimeError as err:
    print("RuntimeError raised:", str(err).startswith("Ambiguous dispatch"))

🔍 Deep dive — reading the table column by column

Each column below is one sample; each row is one stage. Read down a column to see how its answer evolves.

📖 Line-by-line walkthrough

1. The imports — Real comes from numbers (the numeric ABCs); Sized and Iterable from collections.abc.
2. The kind function returns its own label — a debugging trick: instead of formatting something, each branch just names itself so you can see the routing.
3. samples and show(label) — a fixed list of seven values and a helper that prints the branch name for each. :<22 aligns the stage labels.
4. Stage 1 — only int registered. True still prints int (parent lookup); everything else non-int falls back.
5. Stage 2: register for bool — the exact match now exists, so True becomes bool. Nothing else changes.
6. Stage 3: @kind.register(Real) — the explicit form, because the function has no annotation. Floats and Fractions now share one branch.
7. Stage 4: str | bytes and type(None) — a union annotation registers several types at once; None uses the explicit form.
8. Stage 5: register(Decimal) — Decimal had to be added by name because it is not in the numeric tower.
9. [t.__name__ for t in kind.registry] — the registry in registration order. str and bytes appear separately although one function was decorated.
10. kind.dispatch(Fraction) is kind.dispatch(float) — both resolve to the single Real function, so the identity check is True.
11. class Both — implements just enough of two protocols to satisfy two ABCs at once.
12. probe with Sized and Iterable — two ABC registrations that overlap on Both. The call raises RuntimeError; we confirm its message starts with Ambiguous dispatch.

⚠️ Common mistakes

🧪 Try it yourself

Everything comes together. Two generic functions share the same set of types: scale() multiplies a quantity by a factor, format_quantity() prints it. A Recipe class scales an entire ingredient list from 4 servings to 6 or to 2, totals the cost with Money arithmetic, and renders it — without a single isinstance check.

from dataclasses import dataclass
from fractions import Fraction
from functools import singledispatch

class Money:
    def __init__(self, amount):
        self.amount = round(amount, 2)

    def __add__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        return Money(self.amount + other.amount)

    def __mul__(self, factor):
        if not isinstance(factor, (int, float, Fraction)):
            return NotImplemented
        return Money(self.amount * float(factor))

    __rmul__ = __mul__

    def __str__(self):
        return f"PHP {self.amount:,.2f}"

    def __repr__(self):
        return f"Money({self.amount})"

def to_mixed(frac):
    whole, rem = divmod(frac.numerator, frac.denominator)
    if rem == 0:
        return str(whole)
    if whole == 0:
        return f"{rem}/{frac.denominator}"
    return f"{whole} {rem}/{frac.denominator}"

@singledispatch
def format_quantity(value):
    return f"?? {value!r}"

@format_quantity.register
def _(value: int):
    return str(value)

@format_quantity.register
def _(value: Fraction):
    return to_mixed(value)

@format_quantity.register
def _(value: float):
    return to_mixed(Fraction(value).limit_denominator(8))

@format_quantity.register
def _(value: str):
    return value

@format_quantity.register
def _(value: Money):
    return str(value)

@format_quantity.register
def _(value: tuple):
    return "–".join(format_quantity(v) for v in value)

@singledispatch
def scale(value, factor):
    raise TypeError(f"Cannot scale {type(value).__name__}")

@scale.register
def _(value: int, factor):
    return Fraction(value) * factor

@scale.register
def _(value: Fraction, factor):
    return value * factor

@scale.register
def _(value: float, factor):
    return Fraction(value).limit_denominator(16) * factor

@scale.register
def _(value: str, factor):
    return value

@scale.register
def _(value: Money, factor):
    return value * factor

@scale.register
def _(value: tuple, factor):
    return tuple(scale(v, factor) for v in value)

@dataclass
class Ingredient:
    name: str
    qty: object
    unit: str = ""
    cost: Money | None = None

class Recipe:
    def __init__(self, title, servings, ingredients):
        self.title = title
        self.servings = servings
        self.ingredients = ingredients

    def scaled(self, servings):
        factor = Fraction(servings, self.servings)
        items = [
            Ingredient(i.name, scale(i.qty, factor), i.unit,
                       scale(i.cost, factor) if i.cost else None)
            for i in self.ingredients
        ]
        return Recipe(self.title, servings, items)

    def total_cost(self):
        return sum((i.cost for i in self.ingredients if i.cost), Money(0))

    def render(self):
        lines = [f"{self.title} (serves {self.servings})"]
        for i in self.ingredients:
            lines.append(f"  {format_quantity(i.qty):>8} {i.unit:<5} {i.name}")
        lines.append(f"  Estimated cost: {format_quantity(self.total_cost())}")
        return "\n".join(lines)

pancakes = Recipe("Pancakes", 4, [
    Ingredient("flour", 2, "cups", Money(24)),
    Ingredient("milk", Fraction(3, 2), "cups", Money(18)),
    Ingredient("sugar", 2, "tbsp", Money(4)),
    Ingredient("eggs", 1, "", Money(10)),
    Ingredient("salt", "a pinch"),
    Ingredient("butter", (2, 3), "tbsp", Money(15)),
    Ingredient("vanilla", 0.5, "tsp", Money(8)),
])

print(pancakes.render())
print()
print(pancakes.scaled(6).render())
print()
print(pancakes.scaled(2).render())

🔍 Deep dive — following each ingredient from 4 to 6 servings

Scaling from 4 to 6 servings uses the exact factor Fraction(6, 4) = 3/2. Because scale returns Fraction objects (never floats), no rounding error can accumulate. Only at the very end does format_quantity turn the exact fractions into cookbook text.

📖 Line-by-line walkthrough

1. Money.__add__ — adds two Money objects and returns a new one. For any other type it returns NotImplemented (the polite "not my job" from the Polymorphism guide).
2. Money.__mul__ and __rmul__ = __mul__ — multiplies by an int, float or Fraction. Converting with float(factor) keeps the stored amount an ordinary float and makes the intent explicit. __rmul__ makes 2 * price work too.
3. to_mixed and the format_quantity branches — as in Program 3, except the tuple branch is now "–".join(...), which works for ranges of any length.
4. @singledispatch def scale(value, factor) — a second, independent generic function. It dispatches on value only; factor is a plain extra argument. The fallback raises because an unknown type can't be scaled sensibly.
5. scale for int — Fraction(value) * factor promotes the int to an exact fraction first, so 2 × 3/2 is exactly 3.
6. scale for float — snaps with limit_denominator(16) before scaling. Floats are the only branch that loses a little precision, and it is a deliberate, documented choice (sixteenths).
7. scale for str — returns the string as-is. "A pinch" stays "a pinch" at any serving size.
8. scale for Money — just value * factor, leaning on the operator overloading defined earlier.
9. scale for tuple — rebuilds the tuple by calling scale on every element: the same recursive trick as in format_quantity.
10. @dataclass class Ingredient — generates __init__ and __repr__ for free. qty: object admits any quantity type; cost: Money | None = None means "optional price".
11. Recipe.scaled(servings) — builds factor = Fraction(servings, self.servings), then creates a new Recipe whose quantities and costs are scaled. The original is untouched, so you can scale one recipe to many sizes.
12. Recipe.total_cost() — sum(..., Money(0)) starts from a Money(0) so the additions are Money + Money. The if i.cost filter skips salt, which has no price.
13. Recipe.render() — builds one text line per ingredient with fixed column widths (:>8 right-aligns the quantity, :<5 left-aligns the unit), then appends the cost through format_quantity so it uses the Money branch.
14. The three prints — the original recipe, then ×1.5 and ×0.5. The blank print() calls add spacing between the blocks.

⚠️ Common mistakes

🧪 Try it yourself

Task: a data feed sends quantities as decimal.Decimal values such as Decimal("1.50"). Register a Decimal branch that prints them without trailing zeros: 1.5, 2, 100, 0.25. Do not touch the existing int branch.

from decimal import Decimal
from functools import singledispatch

@singledispatch
def format_quantity(value):
    return f"?? {value!r}"

@format_quantity.register
def _(value: int):
    return str(value)

@format_quantity.register
def _(value: Decimal):
    return format(value.normalize(), "f")

for item in [Decimal("1.50"), Decimal("2.00"), Decimal("100"), Decimal("0.250"), 3]:
    print(f"{type(item).__name__:<8} {item!s:>6} → {format_quantity(item)}")

Task: write plural(qty, unit) returning "cup" or "cups" to match the quantity. Rules: exactly 1 is singular; Fraction amounts up to 1 are singular (1/2 cup) and above 1 plural (1 1/2 cups); a range uses its upper end; a str quantity like "a pinch" stays singular.

from fractions import Fraction
from functools import singledispatch

@singledispatch
def plural(qty, unit):
    return unit

@plural.register
def _(qty: int, unit):
    return unit if qty == 1 else unit + "s"

@plural.register
def _(qty: Fraction, unit):
    return unit if qty <= 1 else unit + "s"

@plural.register
def _(qty: float, unit):
    return plural(Fraction(qty).limit_denominator(8), unit)

@plural.register
def _(qty: tuple, unit):
    return plural(qty[-1], unit)

for q in [1, 2, Fraction(1, 2), Fraction(3, 2), 0.75, 2.5, (2, 3), "a pinch"]:
    print(f"{q!s:>10}  {plural(q, 'cup')}")

Task: because bool is a subclass of int, format_quantity(True) currently prints True as if it were a quantity. Make booleans raise ValueError("A bool is not a quantity") while real integers still work.

from functools import singledispatch

@singledispatch
def format_quantity(value):
    return str(value)

@format_quantity.register
def _(value: int):
    return str(value)

@format_quantity.register
def _(value: bool):
    raise ValueError("A bool is not a quantity")

for item in [3, True, False]:
    try:
        print(format_quantity(item))
    except ValueError as err:
        print("ValueError:", err)

Task: a "plugin author" writes two new quantity classes, Splash(ml) and Handful(count=1). They must print as a splash (~15 ml), a handful and 3 handfuls. The plugin code must register itself after and outside the core format_quantity definition — no edits to the core.

from functools import singledispatch

@singledispatch
def format_quantity(value):
    return f"?? {value!r}"

@format_quantity.register
def _(value: int):
    return str(value)

class Splash:
    def __init__(self, ml):
        self.ml = ml

class Handful:
    def __init__(self, count=1):
        self.count = count

@format_quantity.register
def _(value: Splash):
    return f"a splash (~{value.ml} ml)"

@format_quantity.register
def _(value: Handful):
    return "a handful" if value.count == 1 else f"{value.count} handfuls"

for item in [2, Splash(15), Handful(), Handful(3)]:
    print(format_quantity(item))

Task: write a class Cup with a method to_ml(qty) that converts a quantity to millilitres at 240 ml per cup. int gives an int, Fraction gives a float, a tuple converts each end, and anything else raises TypeError("Cannot convert ...").

from fractions import Fraction
from functools import singledispatchmethod

class Cup:
    ML = 240

    @singledispatchmethod
    def to_ml(self, qty):
        raise TypeError(f"Cannot convert {type(qty).__name__}")

    @to_ml.register
    def _(self, qty: int):
        return qty * self.ML

    @to_ml.register
    def _(self, qty: Fraction):
        return float(qty * self.ML)

    @to_ml.register
    def _(self, qty: tuple):
        return tuple(self.to_ml(q) for q in qty)

cup = Cup()
print(cup.to_ml(2))
print(cup.to_ml(Fraction(3, 4)))
print(cup.to_ml((1, Fraction(1, 2))))
try:
    cup.to_ml("a pinch")
except TypeError as err:
    print("TypeError:", err)

Task: the formatter below runs without errors but prints four wrong results. Expected: 1 1/2, 1/2, 2, 1 1/2–2, and a ValueError for True. Find and fix all four bugs.

from fractions import Fraction
from functools import singledispatch

@singledispatch
def format_quantity(value):
    return str(value)

@format_quantity.register(int)
def _(value):
    return str(value)

@format_quantity.register(Fraction)
def _(value):
    whole, rem = divmod(value.numerator, value.denominator)
    return f"{whole} {rem}/{value.denominator}"

@format_quantity.register(tuple)
def _(value):
    return f"{value[0]}–{value[1]}"

print(format_quantity(Fraction(3, 2)))
print(format_quantity(Fraction(1, 2)))
print(format_quantity(Fraction(2, 1)))
print(format_quantity((Fraction(3, 2), 2)))
print(format_quantity(True))

from fractions import Fraction
from functools import singledispatch

def to_mixed(f):
    whole, rem = divmod(f.numerator, f.denominator)
    if rem == 0:
        return str(whole)
    if whole == 0:
        return f"{rem}/{f.denominator}"
    return f"{whole} {rem}/{f.denominator}"

@singledispatch
def format_quantity(value):
    return str(value)

@format_quantity.register(int)
def _(value):
    return str(value)

@format_quantity.register(bool)
def _(value):
    raise ValueError("A bool is not a quantity")

@format_quantity.register(Fraction)
def _(value):
    return to_mixed(value)

@format_quantity.register(tuple)
def _(value):
    return f"{format_quantity(value[0])}–{format_quantity(value[1])}"

print(format_quantity(Fraction(3, 2)))
print(format_quantity(Fraction(1, 2)))
print(format_quantity(Fraction(2, 1)))
print(format_quantity((Fraction(3, 2), 2)))
try:
    print(format_quantity(True))
except ValueError as err:
    print("ValueError:", err)

Habits That Keep It Safe

Key Takeaways

• Single dispatch = one function name, per-type implementations chosen by the first argument's type.
• The undecorated function is the fallback — you decide what an unknown type does.
• Registration is open: new types plug in from any module without editing existing code.
• Lookup follows inheritance and ABCs, which is why True uses the int branch until you register bool.
• Recurse through the generic function for containers so nested values dispatch correctly.
• Use exact Fraction arithmetic for scaling and format once at the end — never chain float errors.