Types & Literals

CXL has 9 value types. Every field value, literal, and expression result is one of these types.

Value types

Type	Rust backing	Description
Null	`Value::Null`	Missing or absent value
Bool	`bool`	`true` or `false`
Integer	`i64`	64-bit signed integer
Float	`f64`	64-bit double-precision float
String	`Box<str>`	UTF-8 text
Date	`NaiveDate`	Calendar date without timezone
DateTime	`NaiveDateTime`	Date and time without timezone
Array	`Vec<Value>`	Ordered collection of values
Map	`IndexMap<Box<str>, Value>`	Key-value pairs

Literal syntax

Integers

Standard decimal notation. Negative values use the unary minus operator.

$ cxl eval -e 'emit a = 42' -e 'emit b = -5' -e 'emit c = 0'

{
  "a": 42,
  "b": -5,
  "c": 0
}

Floats

Decimal notation with a dot. Must have digits on both sides of the decimal point.

$ cxl eval -e 'emit a = 3.14' -e 'emit b = -0.5'

{
  "a": 3.14,
  "b": -0.5
}

Strings

Double-quoted or single-quoted. Supports escape sequences: \\, \", \', \n, \t, \r.

$ cxl eval -e 'emit greeting = "hello world"'

{
  "greeting": "hello world"
}

Booleans

The keywords true and false.

$ cxl eval -e 'emit flag = true' -e 'emit neg = not flag'

{
  "flag": true,
  "neg": false
}

Dates

Hash-delimited ISO 8601 format: #YYYY-MM-DD#.

$ cxl eval -e 'emit d = #2024-01-15#'

{
  "d": "2024-01-15"
}

Null

The keyword null.

$ cxl eval -e 'emit nothing = null'

{
  "nothing": null
}

Schema types

When declaring column types in YAML pipeline schemas, use these type names:

Schema type	CXL type	Description
`string`	String	Text values
`int`	Integer	64-bit integers
`float`	Float	64-bit floats
`bool`	Bool	Boolean values
`date`	Date	Calendar dates
`date_time`	DateTime	Date and time
`array`	Array	Ordered collections
`numeric`	Int or Float	Union type – accepts either
`any`	Any	Unknown type – no type constraints
`nullable(T)`	Nullable(T)	Wrapper – value may be null

Example YAML schema declaration:

schema:
  employee_id: int
  name: string
  salary: nullable(float)
  start_date: date

Type promotion

CXL automatically promotes types in mixed expressions:

Int + Float promotes to Float:

$ cxl eval -e 'emit result = 2 + 3.5'

{
  "result": 5.5
}

Null + T produces Nullable(T): Any operation involving null produces a nullable result.

$ cxl eval -e 'emit result = null + 5'

{
  "result": null
}

Nullable(A) + B unifies to Nullable(unified): When a nullable value meets a non-nullable value, the result type wraps the unified inner type in Nullable.

Type unification rules

The type checker follows these rules when two types meet in an expression:

Same types unify to themselves: Int + Int produces Int
Any unifies with anything: Any + T produces T
Numeric resolves to the concrete type: Numeric + Int produces Int, Numeric + Float produces Float
Int promotes to Float: Int + Float produces Float
Null wraps: Null + T produces Nullable(T)
Nullable propagates: Nullable(A) + B produces Nullable(unified(A, B))
Incompatible types fail: String + Int is a type error

Keyboard shortcuts

Clinker User Guide