<!-- Sema documentation — polymorphism
     Sema is a new AI-native, neurosymbolic programming language most models
     have not been trained on. Full corpus: https://sema.49.12.246.95.sslip.io/llms-full.txt
     Install language support: https://sema.49.12.246.95.sslip.io/install-skill/ -->

# polymorphism

> Traits, enums, and generics — Sema polymorphism without classes or inheritance.

> Traits, enums, and generics — Sema polymorphism without classes or inheritance.

Run it from `sema/`:

```bash
sema check examples/polymorphism
SEMA_STRICT=1 sema run examples/polymorphism
sema assure examples/polymorphism --grade silver
```

## Source

### `src/main.sema`

```sema
"""Polymorphism worked example (§3.9).

Demonstrates the whole trait trio and a functional pipeline in one runnable
program on the deterministic mock engine:

- a **struct conforming via the header list** (`Version`),
- a **struct conforming out of line** with `impl Ord for Money` (retrofit),
- an **enum conforming to the same trait** (`Severity`), defaults grafted too,
- a **bounded generic** `maximum[T: Ord]` reused across all three,
- **default methods** (`less`/`max2`/`clamp`) derived from one `compare`,
- a **supertrait** obligation (`Ord` requires `Eq`),
- **trait objects**: a heterogeneous `list[Renderer]` dispatched dynamically,
  with `is` narrowing (open-world polymorphism — see `plugins.sema`),
- **functional style**: immutable bindings, a comprehension, conditional
  expressions."""

from polymorphism.order import Ord, maximum
from polymorphism.plugins import Text, Bullet, Rule, render_all, count_rules

struct Version (Ord):
    """Ordered by major, then minor."""
    major: int
    minor: int
    def compare(self, other: Version) -> int:
        return (self.major - other.major) if self.major != other.major else (self.minor - other.minor)

# Out-of-line conformance: `Money` is declared plainly, then retrofitted to
# `Ord` — the same defaults graft on as if listed in the header.
struct Money:
    minor_units: int

impl Ord for Money:
    def compare(self, other: Money) -> int:
        return self.minor_units - other.minor_units

# An enum conforms to the very same trait; `less`/`max2`/`clamp` graft onto it.
enum Severity (Ord):
    low
    medium
    high
    def rank(self) -> int:
        return 0 if self == Severity.low else (1 if self == Severity.medium else 2)
    def compare(self, other: Severity) -> int:
        return self.rank() - other.rank()

def main() -> str !{}:
    # Bounded generic over a user struct.
    versions = [Version(major=1, minor=4), Version(major=2, minor=0), Version(major=1, minor=9)]
    latest = maximum(versions)

    # Retrofitted struct + a functional comprehension using a default method.
    prices = [Money(minor_units=1299), Money(minor_units=999), Money(minor_units=1799)]
    dearest = maximum(prices)
    cheaper = [p.minor_units for p in prices if p.less(dearest)]

    # Enum ordering through the grafted defaults.
    top = maximum([Severity.low, Severity.high, Severity.medium])

    # `clamp` is a default method that calls other defaults.
    clamped = Version(major=5, minor=0).clamp(Version(major=1, minor=0), latest)

    # Trait objects: one list, three concrete types, dynamic dispatch + `is`.
    doc = [Text(body="Report"), Rule(width=4), Bullet(item="alpha"), Bullet(item="beta")]
    rendered = render_all(doc)
    rules = count_rules(doc)

    summary = f"latest={latest.major}.{latest.minor} dearest={dearest.minor_units} cheaper={cheaper} top={top.name} clamped={clamped.major}.{clamped.minor} rendered={rendered} rules={rules}"
    print(summary)
    return summary
```

### `src/order.sema`

```sema
"""Reusable ordering vocabulary (§3.9).

`Ord` is built on the supertrait `Eq`. A conforming type supplies a single
required method — `compare` — and inherits every other operation as a *default
method*: `less`, `eq`, `max2`, and `clamp` are written once here and grafted
onto every type that conforms, with the type's own definition winning if it
provides one. `maximum` is a *bounded generic*: it works for any `T` that is
`Ord`, using only the trait's surface."""

pub trait Eq:
    """Equality by value."""
    def eq(self, other: Self) -> bool

pub trait Ord (Eq):
    """A total order. Supply `compare`; the rest is provided for free."""
    def compare(self, other: Self) -> int

    # --- default (provided) methods: written once, reused by every conformer ---
    def less(self, other: Self) -> bool:
        return self.compare(other) < 0

    def eq(self, other: Self) -> bool:
        return self.compare(other) == 0

    def max2(self, other: Self) -> Self:
        return other if self.less(other) else self

    def clamp(self, lo: Self, hi: Self) -> Self:
        return lo if self.less(lo) else (hi if hi.less(self) else self)

# Bounded generic (§3.9): `[T: Ord]` is erased at runtime, but the bound is the
# declared obligation that the element type provides `Ord`, so the body may use
# `max2`. Works uniformly for structs and enums that conform.
pub def maximum[T: Ord](xs: list[T]) -> T !{}:
    mut best = xs[0]
    for x in xs:
        best = best.max2(x)
    return best
```

### `src/plugins.sema`

```sema
"""Trait objects (§3.9) — open-world polymorphism.

A `Renderer` trait with several unrelated concrete implementations, held
together in one `list[Renderer]` and dispatched dynamically. This is the pattern
classes use *inheritance* for (a heterogeneous collection behind an interface),
done with traits + dynamic dispatch instead — third parties can add new
`Renderer`s without touching a central `enum`. `is` recovers the concrete type
when open-world code needs it."""

pub trait Renderer:
    """Anything that can render itself to a line of text."""
    def render(self) -> str

pub struct Text (Renderer):
    body: str
    def render(self) -> str:
        return self.body

pub struct Bullet (Renderer):
    item: str
    def render(self) -> str:
        return f"- {self.item}"

pub struct Rule (Renderer):
    width: int
    def render(self) -> str:
        return "-" * self.width

# A heterogeneous collection behind the trait, dispatched dynamically: each
# element is a different concrete type, resolved at the call site by its runtime
# type. No `enum`, no shared base class.
pub def render_all(items: list[Renderer]) -> str !{}:
    lines = [it.render() for it in items]
    return "|".join(lines)

# `is` narrowing: open-world code can still ask a value's concrete type or test
# trait conformance.
pub def count_rules(items: list[Renderer]) -> int !{}:
    mut n = 0
    for it in items:
        n = n + (1 if it is Rule else 0)
    return n
```

## Reflected API

# `main`

Polymorphism worked example (§3.9).

Demonstrates the whole trait trio and a functional pipeline in one runnable
program on the deterministic mock engine:

- a **struct conforming via the header list** (`Version`),
- a **struct conforming out of line** with `impl Ord for Money` (retrofit),
- an **enum conforming to the same trait** (`Severity`), defaults grafted too,
- a **bounded generic** `maximum[T: Ord]` reused across all three,
- **default methods** (`less`/`max2`/`clamp`) derived from one `compare`,
- a **supertrait** obligation (`Ord` requires `Eq`),
- **trait objects**: a heterogeneous `list[Renderer]` dispatched dynamically,
  with `is` narrowing (open-world polymorphism — see `plugins.sema`),
- **functional style**: immutable bindings, a comprehension, conditional
  expressions.

# `struct Version`

Ordered by major, then minor.

**Fields**

| field | type | descriptor |
|---|---|---|
| `major` | `int` |  |
| `minor` | `int` |  |

# `struct Money`

**Fields**

| field | type | descriptor |
|---|---|---|
| `minor_units` | `int` |  |

# `enum Severity`

**Variants**

- `low`
- `medium`
- `high`

# `def main`

```sema
def main() -> str !{}
```

**Returns** `str`

**Effects** `!{}`


# `order`

Reusable ordering vocabulary (§3.9).

`Ord` is built on the supertrait `Eq`. A conforming type supplies a single
required method — `compare` — and inherits every other operation as a *default
method*: `less`, `eq`, `max2`, and `clamp` are written once here and grafted
onto every type that conforms, with the type's own definition winning if it
provides one. `maximum` is a *bounded generic*: it works for any `T` that is
`Ord`, using only the trait's surface.

# `trait Eq`

Equality by value.

# `trait Ord`

A total order. Supply `compare`; the rest is provided for free.

# `def maximum`

```sema
def maximum[T: Ord](xs: list[T]) -> T !{}
```

**Parameters**

| name | type |
|---|---|
| `xs` | `list[T]` |

**Returns** `T`

**Effects** `!{}`


# `plugins`

Trait objects (§3.9) — open-world polymorphism.

A `Renderer` trait with several unrelated concrete implementations, held
together in one `list[Renderer]` and dispatched dynamically. This is the pattern
classes use *inheritance* for (a heterogeneous collection behind an interface),
done with traits + dynamic dispatch instead — third parties can add new
`Renderer`s without touching a central `enum`. `is` recovers the concrete type
when open-world code needs it.

# `trait Renderer`

Anything that can render itself to a line of text.

# `struct Text`

**Fields**

| field | type | descriptor |
|---|---|---|
| `body` | `str` |  |

# `struct Bullet`

**Fields**

| field | type | descriptor |
|---|---|---|
| `item` | `str` |  |

# `struct Rule`

**Fields**

| field | type | descriptor |
|---|---|---|
| `width` | `int` |  |

# `def render_all`

```sema
def render_all(items: list[Renderer]) -> str !{}
```

**Parameters**

| name | type |
|---|---|
| `items` | `list[Renderer]` |

**Returns** `str`

**Effects** `!{}`

# `def count_rules`

```sema
def count_rules(items: list[Renderer]) -> int !{}
```

**Parameters**

| name | type |
|---|---|
| `items` | `list[Renderer]` |

**Returns** `int`

**Effects** `!{}`