Vad är Design by Contract?

Question

Accepted Answer

**Design by Contract (DbC)** behandlar relationen mellan en metod och dess anropare som ett formellt avtal, definierat av tre saker: **förvillkor** (vad anroparen måste garantera), **eftervillkor** (vad metoden garanterar i gengäld) och **invarianter** (vad som förblir sant för objektet hela tiden).

## De tre förpliktelserna

```text
PRECONDITION  → caller's duty: inputs/state the method requires to run correctly
POSTCONDITION → method's duty: what it promises on return (if precondition held)
INVARIANT     → always-true property of the object, before and after every method
```

## I kod

```python
class Account:
    def __init__(self, balance):
        self._balance = balance
        self._check_invariant()

def withdraw(self, amount):
        assert amount > 0, "PRE: amount must be positive"        # precondition
        assert amount <= self._balance, "PRE: sufficient funds"  # precondition
        old = self._balance
        self._balance -= amount
        assert self._balance == old - amount, "POST: balance reduced"  # postcond
        self._check_invariant()

def _check_invariant(self):
        assert self._balance >= 0, "INVARIANT: balance never negative"
```

Om ett *förvillkor* misslyckas, har **anroparen** buggen. Om ett *eftervillkor* eller en *invariant* misslyckas, har **metoden** buggen — kontrakt pekar ut skulden exakt.

## Relation till LSP

DbC gör Liskov precis: en subtyp kan **försämra förvillkor** och **stärka eftervillkor**, men aldrig tvärtom. Det är exakt substitutionsregeln, uttryckt som kontrakt.

## Avvägningar

```text
✓ Bugs surface at the boundary, with clear blame   ✓ Contracts double as documentation
⚠️ Runtime checks cost performance (often disabled in prod via assertions)
⚠️ Not all languages enforce it natively (Eiffel does; most use asserts/validation)
```

## Varför det spelar roll

Kontrakt omvandlar vaga antaganden ("beloppet bör vara positivt, tror jag") till explicita, kontrollerbara regler — och de tilldelar skuld exakt när något går sönder.

De ligger till grund för Liskov-substitution och robust API-design: en metods kontrakt är dess sanna gränssnitt, mer ärligt än bara dess typsignatur.