2.1Tokens

• Identifiers: Alphanumeric symbols beginning with a letter.
• Numbers: Integers and floats. Negative numbers start with -.
• Strings: Double-quoted UTF-8 strings.
• Symbols: (, ), [, ], {, }, :, .., <, >, ,

2.2Comments

• Line Comments: Begin with | and continue to end of line.

3.1Programs

A Graffiticode program is a sequence of one or more let declarations, followed by a single top-level expression, and terminated with ...

let double = <x: mul 2 x>..
map (double) [1 2 3]..

The top-level expression must always be followed by ...

3.2Expressions

[1 2 3]

{ name: "Alice", age: 30 }

<x: add x 1>

let double = <x: mul 2 x>..

3.3Pattern Matching

Pattern matching is done using case: case x of 0: "zero" 1: "one" _: "other" end

Pattern matching on function arguments is disallowed.

red

case color of
  red: "warm"
  blue: "cool"
  _: "other"
end

4.1Primitive Types

• number – Represents integers or floating-point numbers.
• string – Represents UTF-8 strings.
• bool – Represents Boolean values: true and false.
• json – Represents any JSON-compatible value (opaque, untyped).
• any – Used internally to denote an unconstrained type (e.g., during inference).

4.2Non-Nullable Types

Graffiticode types are nullable by default. To indicate that a value must not be null, append an exclamation mark (!) to the type name.

string!     | a non-nullable string
[number]!   | a non-nullable list of numbers

A non-nullable type is guaranteed to hold a value. Nullable types may be null or missing.

In general:

• T allows null
• T! disallows null

Type inference will propagate non-nullability when safe.

4.3Composite Types

• Lists – Written as [T] where T is any type. gc [string] | list of strings [number] | list of numbers [[bool]] | list of lists of booleans
• Records – Key-value maps with known keys and types. gc { name: string, age: number }
• Tuples – Ordered, fixed-length collections with heterogeneous types. gc (number, string, bool)

4.4Function Types

Functions are written using Graffiticode lambda signature syntax: gc <number number: number> | function taking two numbers and returning a number <string: [string]> | function taking a string and returning a list of strings <list record: record> | common signature for structural transformation

Function types are curried by default. That means: gc <number number: number> is equivalent to a function that returns another function: gc <number: <number: number>>

4.5Tag Value Type

Tag values are symbolic constants with no arguments or payload. They are considered members of an implicit tag set, and their type is usually inferred based on the context in which they appear—such as in pattern matching.

tag

tag ∈ { red, green, blue }

case color of
  red: "warm"
  blue: "cool"
  _: "other"
end

4.6Example: Annotated Definitions

let inc = <x: add x 1>  | type: <number: number>
let greet = <name: concat ["Hello, " name]>  | type: <string: string>
let zip = <xs ys: zipLists xs ys>  | type: <[T] [U]: [(T, U)]>

(Note: actual Graffiticode does not use type annotations in let bindings; types are inferred.) (for illustration)

let inc = <x: add x 1>  | type: <number: number>
let greet = <name: concat ["Hello, " name]>  | type: <string: string>
let zip = <xs ys: zipLists xs ys>  | type: <[T] [U]: [(T, U)]>

(Note: actual Graffiticode does not use type annotations in let bindings; types are inferred.)

5.1Evaluation Model

• Purely functional: no side effects
• Strict evaluation: arguments evaluated before function application
• Immutable data: all values are immutable

Many built-in functions in Graffiticode follow a model-threading pattern. In this pattern, functions are defined to take one or more arguments followed by a model, which represents the current state of the program or view. The function uses the earlier arguments to compute an update to the model and returns a new model as its result.

This style enables a declarative and order-independent composition of functions. Since each function call returns a new model, multiple calls can be reordered without changing the final result, provided the functional dependencies are preserved.

This approach draws inspiration from Model-View-Update (MVU) architectures, in which the model represents the application state and functions describe pure, deterministic transformations of that state.

5.2Functions

• Fixed arity: every function has a known number of parameters
• Curried by default: partial application supported

5.3Scoping

• Lexical scoping
• Shadowing allowed within nested scopes

5.4Errors

• Syntax errors: raised during parsing
• Type errors: raised during compilation
• Runtime errors: e.g., out-of-bounds access

6.1Types

• number
• string
• bool
• list
• record
• tuple
• json

6.2Built-in Functions

add 2 3  | returns 5

and false false  | returns false
and false true   | returns false
and true false   | returns false
and true true    | returns true

apply add [1 2]  | returns 3

div 10 2  | returns 5

equiv 1 1        | returns true
equiv "a" "a"    | returns true
equiv true true  | returns true
equiv 1 2        | returns false
equiv "a" "b"    | returns false

filter (<x: mod x 2>) [1 2 3 4]  | returns [1 3]

get "b" {a: 1, b: 2}  | returns 2

hd [10 20 30]  | returns 10

isEmpty []  | returns true

log "Hello"  | prints "Hello" to console and returns "Hello"
log (add 1 2)  | prints 3 to console and returns 3

map (<x: add x 1>) [1 2 3]  | returns [2 3 4]

max 5 10  | returns 10

min 5 10  | returns 5

mod 10 3  | returns 1

mul 4 3  | returns 12

not true   | returns false
not false  | returns true

nth 1 [10 20 30]  | returns 20

or false false  | returns false
or false true   | returns true
or true false   | returns true
or true true    | returns true

range 1 10 2  | returns [1 3 5 7 9]

reduce (<a b: add a b>) 0 [1 2 3 4]  | returns 10

set "a" 2 {a: 1}  | returns {a: 2}

sub 5 2  | returns 3

tl [10 20 30]  | returns [20 30]