Types & Atoms

Types & Atoms

LOVE-LANG has a rich, extensible type system built from the ground up. Every value in LOVE is a typed atom or a typed list.

---

Primitive Atoms

The atomic building blocks of LOVE:

String

Double-quoted UTF-8 strings:

greeting = "Hello, World!"
multiword is "linguistics oriented programming"

Number

Integer or floating-point:

count   = 42
ratio   = 3.14159
version = 0.0.1

Boolean

active   = true
disabled = false

Symbol

Lisp-style keyword constants — always prefixed with ::

mode   = :production
status = :active
color  = :pink

Identifier

Bareword references to other keys:

alias = my-other-value

Datetime

ISO 8601 formatted date/time values:

created-at = 2026-01-01T00:00:00Z

---

Type Annotations

LOVE provides two syntaxes for type annotations:

Angle-Bracket Style

name   @[String]  = "Alice"
age    @[Number]  = 30
active @[Boolean] = true
tags   @[List]    = [:admin :user]

Colon Style

name   :String  = "Alice"
age    :Number  = 30
active :Boolean = true

Both styles are equivalent and interchangeable.

---

Parameterized Types

Types can be parameterized with sub-types:

ids    @[List[Number]]  = [1 2 3 4 5]
names  @[List[String]]  = ["Alice" "Bob" "Carol"]
init   @[List[String]]  = [#! [args :List[String]] ]

---

Type Contracts (L3)

For complex structural types, define a type contract using triple brackets:

# Define the contract
UserPayload = [[[
  name   @[String]
  email  @[String]
  age    @[Number]
  active @[Boolean]
  roles  @[List[Symbol]]
]]]

# Validate input against it
validated = [[[ UserPayload ]]] raw-user-input

Type contracts are evaluated at compile-time and produce hard errors if the data shape doesn’t match.

---

Inference

LOVE-LANG can infer types from assignment:

# Type inferred as String
greeting = "Hello"

# Type inferred as Number
count = 42

# Type forced via annotation (overrides inference)
count @[String] = "42"

Tip

Prefer explicit type annotations at programme boundaries (API inputs and outputs) and let inference handle internal logic. This gives you the best of both worlds: safety at the edges, fluency in the middle.

---

Custom Types

You can define custom types that extend the built-in type system:

# A custom product type
Address = [[[
  street  @[String]
  city    @[String]
  country @[String]
  postal  @[String]
]]]

# A custom sum type (union)
Result = [[[
  :ok   value @[Any]
  :err  message @[String]
]]]

---

Type Coercion

LOVE does not coerce types automatically. If you need to convert between types, use the standard library:

# String to Number
n = [[ Number.from-string "42" ]]

# Number to String
s = [[ String.from-number 42 ]]

# List to String (join)
csv = [[ String.join "," ["a" "b" "c"] ]]