Built-in types

Jadpo comes with its types built in. You use them without declaring or importing anything, and you can't reuse their names for your own types. There are three groups: the six representation types, the standard types, and a few types the language's own features need.

Representation types

The representation types say how a value is held: as a number, as text, as bytes. They are the raw material you build your own types from.

There is no Float. Arithmetic on Decimal is exact, and its other operations are under decimal. (Numbers).

Text that arrives from outside, such as a request body, is put into Unicode's NFC form as it is read, before its rules are checked. NFC writes each character one way, so the same text always compares equal.

By default a Uuid accepts any UUID version and is kept in lowercase. The IDs Jadpo generates for new records are version 7. A named type can fix the version, which decides both what it accepts and what it generates:

entity Order {    id: Uuid  // generated as version 7}type PartnerRef = Uuid {    version: UuidVersion.v4  // accepts and generates only version 4}

Standard types

The standard types are one shared definition each of the things most apps need: a postal address, an amount of money, a length, a point on the earth. Without them, every app and every package would invent its own. Each has one way to build it that checks its rules, one JSON shape and one storage shape. Its fields are named, never positional: Point { latitude: ... longitude: ... }.

Their names are global, like Int, so you never import one. Their operations are grouped under a prefix such as money., units. or temporal.. There are 253 standard types, and The standard types lists every one and every operation. The groups and their best-known types are:

Every standard type, by group. "(enum)" marks a fixed list of values, held as a built-in enum:

The money types have a few rules of their own, because money is where mistakes cost most. Money holds a whole number of a currency's minor units, such as pence or cents, and its Currency. It never holds a decimal number of pounds. A type built on Money takes currency:, rounding:, and min: and max: in minor units. The money. operations (money.from_minor, money.minor, money.sum, money.allocate) build amounts and work them out. A named type for an amount in pounds:

type Sterling = Money {    currency: Currency.gbp    min: 0    rounding: Rounding.half_even}

An amount in another currency doesn't compile where a Sterling is wanted. Use Int for counts and sizes, and Money for amounts of money. Money and payments has the rest.

What every standard type does

Every standard type meets the same contract, so one operation works across all of them:

• Construct and validate. From its parts (PostalCode(raw), or money.from_minor for Money), and from text with text.parse(raw, as: T). Each failure is named by the rule it breaks, and malformed means the text isn't that type at all.
• Show and write. text.format(value, locale:) gives text for people, and text.from(value) gives the canonical text (E.164, ISO codes, ISO 8601) that text.parse reads back. A type with no single text form, such as PostalAddress, can't be asked for one.
• Storage. One shape: a column, or named columns for an object (Money's two).
• JSON. One shape, read and written by json.read, json.write and every route.
• Equality and order. == works on every type; < and sort_by work where order means something (quantities of one kind, Money of one currency, times, SemanticVersion, Percentage).

A type that copies a standard type under another name is the error type.standard_exists. For example, a Booking with only a start and an end, each an Instant, is an InstantRange. When the copy is deliberate, you can decline the error with a reason. A declaration with the same name as a standard type is type.standard_clash. Both are explained under The standard types and A release that adds a standard type.

What the standard types do

Standard types come with their own arithmetic, units and rules, so you write a sum as you would on paper and it is checked as strictly as a call. Which operators work on which types is set by the standard operator table.

A sum of lengths can mix units, and the result is a Length. Inches are written inch, because m means minutes:

type Shelf = Length {}/// A metre, 2.3 inches and 3 centimetres, then 20% of that: a `Length`.function fifth_of(base: Shelf) -> Shelf {    return Shelf((base + 2.3inch + 3cm) * 20%)}

test "units mix within a kind" {    assert fifth_of(Shelf(1metre)) == Shelf((1metre + 2.3inch + 3cm) * 20%)}

Mix up a unit and the compiler says so. Here 1m is one minute, a Duration, which can't be added to a Length:

type Shelf = Length {}/// `m` is minutes, so this adds a `Duration` to a `Length`.function mistaken(base: Shelf) -> Shelf {    return Shelf((1m + 2.3inch + 3cm) * 20%)}

error: A duration and a quantity can't be added: a `Duration` and a `Length` are different kinds --> main.jadpo:5:19  |5 |     return Shelf((1m + 2.3inch + 3cm) * 20%)  |                   ^^^^^^^^^^^^ different kinds  reason: `+` works within one kind of quantity, in any of its units; a `Duration` and a `Length` are different kinds, so the sum means nothing.  next: Use values of one kind, or a product or quotient the table defines (agent)  rule: type.arithmetic_operand  help: https://jadpo.dev/docs/errors/type.arithmetic_operandcheck failed: 1 error, 1 file

Money is a whole number of minor units in one currency, so the operator table allows less on it. A percentage scales it: price * 120% adds 20% VAT. To share an amount out, use money.split, which loses no penny: £10.00 three ways is £3.34, £3.33 and £3.33. Dividing, as in price / 3, is refused with type.money_split, which suggests money.split (Money operations):

type CakePrice = Money {    currency: Currency.gbp    min: 0}type Payment = Money {}/// A price with 20% VAT added.function with_vat(price: CakePrice) -> CakePrice {    return CakePrice(price * 120%)}/// A bill shared three ways, every penny to someone.function shares(total: CakePrice) -> List<Payment> {    return list.map(money.split(total, 3), share -> Payment(share))}

test "VAT and sharing lose nothing" {    var price: CakePrice = CakePrice(money.from_minor(1000, Currency.gbp))    assert with_vat(price) == money.from_minor(1200, Currency.gbp)    assert shares(price) == [        Payment(money.from_minor(334, Currency.gbp)),        Payment(money.from_minor(333, Currency.gbp)),        Payment(money.from_minor(333, Currency.gbp))    ]}

price + 20% could mean two things, so it is refused. Write price * 120% instead:

type CakePrice = Money {    currency: Currency.gbp}/// Twenty percent added to a price: ambiguous, so refused.function more(price: CakePrice) -> CakePrice {    return CakePrice(price + 20%)}

error: `CakePrice` and a percentage can't be added: it could mean two things --> main.jadpo:7:22  |7 |     return CakePrice(price + 20%)  |                      ^^^^^^^^^^^ an amount and a percentage  reason: `price + 20%` could mean the amount raised by 20% of itself, or 20% of some other amount; the standard operator table refuses it rather than guess. A percentage scales money by `*`.  next: Write `price * 120%`, or `price + price * 20%`, whichever is meant (agent)  rule: type.arithmetic_operand  help: https://jadpo.dev/docs/errors/type.arithmetic_operandcheck failed: 1 error, 1 file

Adding two amounts whose types are in different currencies is a compile error:

type CakePrice = Money {    currency: Currency.gbp}type EuroPrice = Money {    currency: Currency.eur}/// A cake in pounds and a delivery charged in euros.function delivered(price: CakePrice, delivery: EuroPrice) -> CakePrice {    return CakePrice(price + delivery)}

error: `CakePrice` and `EuroPrice` can't be added: they're in different currencies --> main.jadpo:11:22   |11 |     return CakePrice(price + delivery)   |                      ^^^^^^^^^^^^^^^^ GBP and EUR  reason: `CakePrice` is in GBP and `EuroPrice` in EUR, as their types or the calls that made them fix; amounts are added only in one currency.  next: Use two amounts in the same currency (agent)  rule: type.arithmetic_operand  help: https://jadpo.dev/docs/errors/type.arithmetic_operandcheck failed: 1 error, 1 file

Dates, times and temperatures work the same way. A CalendarDate plus a one-month CalendarPeriod stops at the last day of the month when the day doesn't exist there. Instant - Instant gives a Duration. Subtracting one temperature from another gives a TemperatureDifference:

type DeliveryDay = CalendarDate {}type SeenAt = Instant {}type Gap = Duration {}/// A day a month on: the 31st of January gives the last day of February.function month_on(day: DeliveryDay) -> DeliveryDay {    return DeliveryDay(        day + CalendarPeriod {            years: 0            months: 1            days: 0        }    )}/// How long between two moments.function between(start: SeenAt, end: SeenAt) -> Gap {    return Gap(end - start)}

test "calendar and clock arithmetic" {    assert month_on(DeliveryDay("2026-01-31")) == DeliveryDay("2026-02-28")    assert between(SeenAt("2026-10-25T09:00:00Z"), SeenAt("2026-10-25T11:30:00Z")) == Gap(150m)    assert 25degC - 20degC == units.of(5, TemperatureDifferenceUnit.kelvin)}

Other built-in types

These types belong to features of the language. Each row links the page that covers the feature.

The batch types' fields, as Batches uses them:

The literals, values written straight into code, are true and false, whole numbers (25, -3), decimals (1.25), strings ("Hello", with \", \\, \n, \r and \t escapes) and none.