Syntax glossary

Essence writes several things with punctuation that other languages spell differently. § opens a comment, :: calls a method, @ is the receiver (the value a method was called on) and <- returns. This page lists every such symbol, keyword and block, each under a fixed anchor. Look one up here when you meet it in code. Each entry says what the form is, where it is legal and what it is not. It then shows a small program and names the page that teaches it.

implementation {
	§ `§` starts a comment. `::` calls a method, `@` is the receiver, `<-` returns.
	namespace Doubling for Integer {
		doubled() -> Integer {
			<- @::multiply(with 2)
		}
	}

	§ `#` names a case, `/` writes a fraction, `{ … }` holds a record.
	constant rounded = 7/2::round(toward #Down)
	constant point   = { x = 3, y = 4 }

	Terminal.print(21::doubled()) § 42
	Terminal.print(rounded) § 3
	Terminal.print(point.x) § 3
}

Terminal.print writes a value and a line break, and each § comment at the end of a line shows what that line prints. The entries are grouped by kind. Three sections close the page: words that look like keywords but are not, places where spacing changes the meaning, and what has no syntax at all.

Comments

§ comment

implementation {
	§ A comment runs to the end of its line.
	constant price = 12 § It may follow code on the same line.

	Terminal.print(price) § 12
}

Taught on Programs and values.

§§ documentation comment

implementation {
	§§ Adds a fifth to a price.
	§§
	§§ @param _ — the price before tax
	§§ @returns — the price after tax
	function withTax(_ price: Integer) -> Integer {
		<- price::add(price::quotient(dividingBy 5))
	}

	Terminal.print(withTax(10)) § 12
}

Taught on Documentation comments.

§? value comment

implementation {
	function double(_ value: Integer) -> Integer {
		<- value::multiply(with 2)
	}
}

tests {
	test "doubles" {
		constant doubled = double(21) §?

		expect doubled::is(42)
	}
}

Taught on Tests.

Sigils

A sigil is a symbol with a meaning of its own: a call, a return, a case, a fraction.

@ receiver

implementation {
	§ in a refinement: the value being tested
	type Digit = Integer where @::isBetween(0, and 9)

	§ in a method: the receiver
	namespace Doubling for Integer {
		doubled() -> Integer {
			<- @::multiply(with 2)
		}
	}

	constant digit: Digit            = 7
	constant input: Integer | String = "seven"

	§ in a match arm: the matched value, narrowed to the arm
	constant text = match input -> String {
		case Integer { <- "a number" }
		case String  { <- @ }
	}

	Terminal.print(digit::doubled()) § 14
	Terminal.print(text) § seven
}

Taught on Choices and match, Checked refinements and Namespaces and methods.

:: method call

implementation {
	constant price = 250

	Terminal.print(price::add(50)) § 300
	Terminal.print(price::add(50)::multiply(with 2)) § 600
	Terminal.print(3/4::numerator()) § 3
}

Taught on Method calls.

::<Name> namespace pick

implementation {
	namespace Euros for Integer {
		shown() -> String {
			<- "{@} EUR"
		}
	}

	namespace Dollars for Integer {
		shown() -> String {
			<- "{@} USD"
		}
	}

	Terminal.print(5::<Euros>shown()) § 5 EUR
	Terminal.print(5::<Dollars>shown()) § 5 USD
}

Taught on Namespaces and methods.

::<Protocol> protocol pick

implementation {
	protocol Sized {
		size() -> Integer

		isEmpty() -> Boolean {
			<- @::size()::is(0)
		}
	}

	type Shelf = { books: Integer }

	namespace Shelves for Shelf is Sized {
		size() -> Integer {
			<- @.books
		}
	}

	constant shelf: Shelf = { books = 0 }

	Terminal.print(shelf::<Sized>isEmpty()) § true
	Terminal.print(5::<Equatable>isNot(3)) § true
}

Taught on Protocols.

<- return

implementation {
	function sign(_ value: Integer) -> String {
		if value::isNegative() {
			<- "negative"
		}

		<- "not negative"
	}

	Terminal.print(sign(-3)) § negative
	Terminal.print(sign(3)) § not negative
}

Taught on Functions.

-> return type

implementation {
	§ the type a function returns
	function half(_ value: Integer) -> Rational {
		<- value::divide(by 2)
	}

	§ a function type: takes an Integer, returns a Rational
	constant halve: (_: Integer) -> Rational = half
	constant amount: Integer | Rational      = halve(3)

	§ the type a match returns
	constant kind = match amount -> String {
		case Integer  { <- "whole" }
		case Rational { <- "a fraction" }
	}

	Terminal.print(halve(3)) § 3/2
	Terminal.print(kind) § a fraction
}

Taught on Functions.

# case

implementation {
	choice Door {
		Open,
		Shut,
	}

	constant front: Door = #Open
	constant back        = Door#Shut

	Terminal.print(front::is(#Open)) § true
	Terminal.print(back::is(front)) § false
	Terminal.print(7/2::round(toward #Up)) § 4
}

Taught on Choices and match.

| union

implementation {
	function described(_ value: Integer | String) -> String {
		<- match value -> String {
			case Integer { <- "the number {@}" }
			case String  { <- "the text {@}" }
		}
	}

	Terminal.print(described(3)) § the number 3
	Terminal.print(described("three")) § the text three
}

Taught on Unions and type aliases.

/ fraction

implementation {
	constant share = 3/4

	Terminal.print(share) § 3/4
	Terminal.print(6/8) § 3/4
	Terminal.print(share::add(1/4)) § 1
}

Taught on Programs and values and Numbers.

_ underscore

implementation {
	§ no label on a parameter
	function double(_ value: Integer) -> Integer {
		<- value::multiply(with 2)
	}

	§ a digit group
	constant amount: Integer | String = 1_000

	§ a parameter the body ignores
	constant zero = (_: Integer) -> Integer { <- 0 }

	§ the arm for everything else
	constant kind = match amount -> String {
		case String { <- @ }
		case _      { <- "not text" }
	}

	Terminal.print(double(21)) § 42
	Terminal.print([1, 2, 3]::map((_) { <- 0 })) § [0, 0, 0]
	Terminal.print(zero(7)) § 0
	Terminal.print(kind) § not text
}

Taught on Functions and Choices and match.

. dot

implementation {
	constant point = { x = 3, y = 4 }
	constant items = [{ price = 2 }, { price = 5 }]

	Terminal.print(point.x) § 3
	Terminal.print(Number.Pi) § π
	Terminal.print(items::map(.price)) § [2, 5]
	Terminal.print(0.75) § 3/4
}

Taught on Method calls and Records.

- minus

implementation {
	constant balance = 250

	Terminal.print(-7) § -7
	Terminal.print(-7::absolute()) § 7
	Terminal.print(balance::negate()) § -250
}

Taught on Method calls.

\ escape

implementation {
	Terminal.print("she said \"hi\"") § she said "hi"
	Terminal.print("a \\ b") § a \ b
	Terminal.print("\{not a hole\}") § {not a hole}
	Terminal.print("tab\there"::length()) § 8
	Terminal.print("\u{1F600}") § 😀
	Terminal.print("\u{1B}"::length()) § 1
}

Taught on Programs and values.

Brackets and separators

{ } braces

implementation {
	type Point = { x: Integer, y: Integer }

	constant origin: Point = { x = 0, y = 0 }
	constant moved         = { origin with x = 5 }
	constant { x } = moved

	Terminal.print({ x }) § { x = 5 }
	Terminal.print("moved to {x}") § moved to 5
}

Taught on Records.

[ ] brackets

implementation {
	constant primes = [2, 3, 5]
	constant ages   = ["ada" = 36, "alan" = 41]
	constant nobody: Dictionary<String, Integer> = [=]
	constant older = [ages with "ada" = 37]

	Terminal.print(primes) § [2, 3, 5]
	Terminal.print(older) § ["ada" = 37, "alan" = 41]
	Terminal.print(nobody) § [=]
}

Taught on Programs and values and Dictionaries.

( ) parentheses

implementation {
	function add(_ a: Integer, _ b: Integer) -> Integer {
		<- a::add(b)
	}

	constant double: (_: Integer) -> Integer = (_ n: Integer) -> Integer {
		<- n::multiply(with 2)
	}
	constant found: Optional<Integer>        = #Value(add(1, 2))

	Terminal.print(double(add(1, 2))) § 6
	Terminal.print(found) § Value(3)
}

Taught on Functions and Method calls.

< > angle brackets

implementation {
	function firstOf<infer Item>(
		_ items: List<Item>,
		or fallback: Item,
	) -> Item {
		<- items::firstItem(defaultingTo fallback)
	}

	constant names: List<String> = []

	Terminal.print(firstOf(names, or "nobody")) § nobody
	Terminal.print(names::firstItem()::is(Optional<String>#Empty)) § true
}

Taught on Generics.

: colon

implementation {
	type Point = { x: Integer, y: Integer }

	constant origin: Point = { x = 0, y = 0 }

	function shifted(_ point: Point, by amount: Integer) -> Point {
		<- { point with x = point.x::add(amount) }
	}

	Terminal.print(shifted(origin, by 2)) § { x = 2, y = 0 }
}

Taught on Programs and values.

= equals

implementation {
	variable count = 0

	count = count::add(1)

	function greet(_ name: String, with greeting: String = "Hello") -> String {
		<- "{greeting}, {name}"
	}

	Terminal.print(count) § 1
	Terminal.print(greet("Ada")) § Hello, Ada
	Terminal.print({ x = 1 }) § { x = 1 }
	Terminal.print(["ada" = 36]) § ["ada" = 36]
}

Taught on Programs and values.

, comma

implementation {
	constant sides  = [3, 4, 5]
	constant corner = { x = 1, y = 2 }

	Terminal.print(sides::length()) § 3
	Terminal.print("essence"::slice(from 1, to 3)) § ss
	Terminal.print(corner.x) § 1
}

Taught on Method calls.

Declaration keywords

implementation

implementation {
	Terminal.print("hello") § hello
}

Taught on Programs and values.

constant

implementation {
	constant greeting        = "Hello"
	constant answer: Integer = 42

	Terminal.print(greeting) § Hello
	Terminal.print(answer) § 42
}

Taught on Programs and values.

variable

implementation {
	variable count = 0

	count = count::add(1)
	count = count::add(1)

	Terminal.print(count) § 2
}

Taught on Programs and values.

type

implementation {
	type Point = { x: Integer, y: Integer }
	type Amount = Integer | Rational
	type Digit = Integer where @::isBetween(0, and 9)

	constant corner: Point = { x = 1, y = 2 }
	constant price: Amount = 3/2
	constant seven: Digit  = 7

	Terminal.print(corner.x::add(seven)) § 8
	Terminal.print(price) § 3/2
}

Taught on Unions and type aliases and Checked refinements.

choice

implementation {
	choice Shape {
		Circle { radius: Integer },
		Square { side: Integer },
		Point,
	}

	constant shape: Shape = #Square({ side = 2 })
	constant width        = match shape -> Integer {
		case #Circle { <- @.radius::multiply(with 2) }
		case #Square { <- @.side }
		case #Point  { <- 0 }
	}

	Terminal.print(width) § 2
}

Taught on Choices and match.

protocol

implementation {
	protocol Named {
		name() -> String
	}

	protocol Greeter is Named {
		static blank() -> Self

		greeting() -> String {
			<- "Hello, {@::name()}"
		}
	}

	type Person = { first: String }

	namespace People for Person is Greeter {
		static blank() -> Person {
			<- { first = "nobody" }
		}

		name() -> String {
			<- @.first
		}
	}

	constant ada: Person = { first = "Ada" }

	Terminal.print(ada::greeting()) § Hello, Ada
	Terminal.print(People.blank()::greeting()) § Hello, nobody
}

Taught on Protocols.

namespace

implementation {
	namespace Money for Integer {
		cents() -> Integer {
			<- @::multiply(with 100)
		}
	}

	type Box<Item> = { value: Item }

	namespace Boxes<infer Item> for Box<Item>
		is Printable where Item is Printable
	{
		toString() -> String {
			<- "Box({@.value})"
		}
	}

	constant box: Box<Integer> = { value = 3 }

	Terminal.print(3::cents()) § 300
	Terminal.print(box) § Box(3)
}

Taught on Namespaces and methods and Protocols.

function

implementation {
	function greet(_ name: String, with greeting: String = "Hello") -> String {
		<- "{greeting}, {name}!"
	}

	Terminal.print(greet("Ada")) § Hello, Ada!
	Terminal.print(greet("Ada", with "Hi")) § Hi, Ada!
}

Taught on Functions.

static

implementation {
	namespace Clock for Integer {
		static noon = 43_200

		static hours(_ count: Integer) -> Integer {
			<- count::multiply(with 3_600)
		}

		isAfterNoon() -> Boolean {
			<- @::isGreaterThan(Clock.noon)
		}
	}

	Terminal.print(Clock.noon) § 43200
	Terminal.print(Clock.hours(13)::isAfterNoon()) § true
}

Taught on Namespaces and methods.

overload

implementation {
	namespace Wrapping for String {
		overload wrapped {
			() -> String {
				<- "({@})"
			}

			(in fence: String) -> String {
				<- "{fence}{@}{fence}"
			}
		}
	}

	Terminal.print("essence"::wrapped()) § (essence)
	Terminal.print("essence"::wrapped(in "*")) § *essence*
}

Taught on Namespaces and methods.

infer

implementation {
	function pair<infer Item>(_ first: Item, with second: Item) -> List<Item> {
		<- [first, second]
	}

	Terminal.print(pair(1, with 2)) § [1, 2]
	Terminal.print(pair("a", with "b")) § ["a", "b"]
}

Taught on Generics.

declarations

No page teaches it, because a program never writes it. A program opens with implementation.

Modules

A file holds up to four blocks, in this order: import, implementation, export and tests. The entries below import from this file:

implementation {
	type Rectangle = { width: Integer, height: Integer }

	function area(of rectangle: Rectangle) -> Integer {
		<- rectangle.width::multiply(with rectangle.height)
	}

	constant unitSide = 1
}

export {
	Rectangle
	area
	unitSide
}

import

import {
	from "./Shapes.es" {
		Rectangle
		area
	}
}

implementation {
	constant card: Rectangle = { width = 3, height = 4 }

	Terminal.print(area(of card)) § 12
}

Taught on Modules.

export

import {
	from "./Shapes.es" { Rectangle }
}

implementation {
	constant unit: Rectangle = { width = 1, height = 1 }
}

export {
	unit
	from "./Shapes.es" { area }
}

Taught on Modules.

from

import {
	from "./Geometry.es" {
		area
		unit
	}
}

implementation {
	Terminal.print(area(of unit)) § 1
}

Taught on Modules.

as

import {
	from "./Shapes.es" {
		area as surface
		unitSide as side
	}
}

implementation {
	Terminal.print(surface(of { width = side, height = 5 })) § 5
}

Taught on Modules and Patterns.

tests block

implementation {
	function double(_ value: Integer) -> Integer {
		<- value::multiply(with 2)
	}
}

tests {
	test "doubles a number" {
		expect double(21)::is(42)
	}
}

Taught on Tests.

Expressions and control flow

if

implementation {
	constant count = 5

	if count::isZero() {
		Terminal.print("none")
	} else if count::isGreaterThan(3) {
		Terminal.print("many") § many
	} else {
		Terminal.print("a few")
	}
}

Taught on Conditions.

define

implementation {
	function grade(_ score: Integer) -> String {
		<- define {
			as "pass" if score::isGreaterThanOrEqualTo(50)
			as "fail" otherwise
		}
	}

	Terminal.print(grade(72)) § pass
	Terminal.print(grade(31)) § fail
}

Taught on Conditions.

otherwise

implementation {
	constant windy  = false
	constant jacket = define {
		as "coat" if windy
		as "none" otherwise
	}

	Terminal.print(jacket) § none
}

Taught on Conditions.

match

implementation {
	constant found: Optional<Integer> = [4, 8]::item(at 1)
	constant item = match found -> Integer {
		case #Value(item) { <- item }
		case #Empty       { <- 0 }
	}

	Terminal.print(item) § 8
}

Taught on Choices and match.

case

implementation {
	function described(_ value: Integer | String) -> String {
		<- match value -> String {
			case 0       { <- "zero" }
			case Integer { <- "a number" }
			case "yes"   { <- "agreement" }
			case _       { <- "some text" }
		}
	}

	Terminal.print(described(0)) § zero
	Terminal.print(described(3)) § a number
	Terminal.print(described("no")) § some text
}

Taught on Choices and match.

where guard

implementation {
	function described(_ reading: Integer | String) -> String {
		<- match reading -> String {
			case Integer where @::isNegative() { <- "below zero" }
			case Integer { <- "zero or more" }
			case String  { <- @ }
		}
	}

	Terminal.print(described(-4)) § below zero
	Terminal.print(described(4)) § zero or more
}

Taught on Choices and match.

with

implementation {
	constant server  = {
		host = "localhost",
		port = 80,
		tls = { enabled = false },
	}
	constant secured = { server with port = 443, tls.enabled = true }
	constant local   = { server with tls.{ enabled = true } }
	constant ages    = ["ada" = 36]

	Terminal.print(secured.port) § 443
	Terminal.print(local.tls.enabled) § true
	Terminal.print(server.port) § 80
	Terminal.print([ages with "alan" = 41]) § ["ada" = 36, "alan" = 41]
}

Taught on Records and Dictionaries.

start

implementation {
	function slowly(_ value: Integer) -> Future<Integer> {
		complete Async.sleep(milliseconds 1)

		<- value
	}

	constant running = start slowly(7)

	Terminal.print(complete running) § 7
}

Taught on Asynchrony.

complete

implementation {
	function doubled(_ value: Integer) -> Future<Integer> {
		constant waited = complete Async.deferred(() { <- value })

		<- waited::multiply(with 2)
	}

	Terminal.print(complete doubled(21)) § 42
}

Taught on Asynchrony.

Interpolation "{…}"

implementation {
	constant name  = "Ada"
	constant count = 3

	Terminal.print("Hello, {name}! You have {count::add(1)} messages.") § Hello, Ada! You have 4 messages.
}

Taught on Programs and values and Strings.

Literals

implementation {
	Terminal.print(1_000) § 1000
	Terminal.print(-3/4) § -3/4
	Terminal.print(0.75) § 3/4
	Terminal.print(0.1::add(0.2)::is(0.3)) § true
	Terminal.print("text") § text
	Terminal.print(true) § true
	Terminal.print([1, 2]) § [1, 2]
	Terminal.print({ x = 1 }) § { x = 1 }
	Terminal.print(["a" = 1]) § ["a" = 1]
	Terminal.print({}) § {}
}

Taught on Programs and values, Numbers and Dictionaries.

Labels

implementation {
	function letter(of text: String, at position: Integer) -> String {
		<- text::slice(from position, to position::add(1))
	}

	Terminal.print(letter(of "essence", at 1)) § s
	Terminal.print(7::clamp(between 1, and 5)) § 5
}

Taught on Method calls and Functions.

Function literal

implementation {
	constant double = (_ value: Integer) -> Integer {
		<- value::multiply(with 2)
	}

	Terminal.print([1, 2, 3]::map((n) { <- n::add(1) })) § [2, 3, 4]
	Terminal.print(double(21)) § 42
}

Taught on Functions as values.

Member path

implementation {
	constant products = [
		{ name = "pen", price = 3 },
		{ name = "ink", price = 12 },
	]

	Terminal.print(products::map(.name)) § ["pen", "ink"]
	Terminal.print(products::sort(on .price, in #Descending)::map(.name)) § ["ink", "pen"]
}

Taught on Functions as values.

Patterns

A pattern names the parts of a record. One grammar is written in six places: a match arm, a case’s payload, a parameter, a function literal’s parameter, a declaration, and require in a test.

{ x } member name

implementation {
	constant point = { x = 3, y = 4 }
	constant { x, y } = point

	Terminal.print(x::add(y)) § 7
}

Taught on Patterns.

{ x: Type } member type

implementation {
	type Click = { x: Integer, y: Integer }
	type Key = { key: String }

	constant input: Click | Key = { key = "q" }
	constant shown = match input -> String {
		case { key: String } { <- "pressed {key}" }
		case { x, y }        { <- "clicked {x}, {y}" }
	}

	Terminal.print(shown) § pressed q
}

Taught on Patterns.

{ x = value } member value

implementation {
	type Click = { x: Integer, y: Integer }
	type Key = { key: String }

	constant input: Click | Key = { x = 0, y = 7 }
	constant shown = match input -> String {
		case { x = 0, y } { <- "on the y axis at {y}" }
		case { x, y }     { <- "at {x}, {y}" }
		case { key }      { <- "pressed {key}" }
	}

	Terminal.print(shown) § on the y axis at 7
}

Taught on Patterns.

as in a pattern

implementation {
	constant line = { start = { x = 1, y = 2 }, label = "edge" }
	constant { start as { x as startX }, label as name } = line

	Terminal.print("{name} starts at {startX}") § edge starts at 1
}

Taught on Patterns.

{ … } as whole whole value

implementation {
	type Size = { width: Integer, height: Integer }

	function area(of { width, height } as size: Size) -> String {
		<- "{size.width} by {size.height} is {width::multiply(with height)}"
	}

	Terminal.print(area(of { width = 3, height = 4 })) § 3 by 4 is 12
}

Taught on Patterns.

Tests

test

implementation {
	function double(_ value: Integer) -> Integer {
		<- value::multiply(with 2)
	}
}

tests {
	constant input = 21

	test "doubles {input}" {
		expect double(input)::is(42)
	}
}

Taught on Tests.

suite

implementation {
	constant lions = { team = "Lions", points = 0 }
}

tests {
	suite "a win" {
		constant won = { lions with points = 3 }

		test "adds three points" {
			expect won.points::is(3)
		}

		test "leaves the original alone" {
			expect lions.points::is(0)
		}
	}
}

Taught on Tests.

expect

implementation {
	constant scores = [3, 1, 2]
}

tests {
	test "sorts the scores" {
		expect scores::sort()::is([1, 2, 3])
		expect scores::length()::is(3)
	}
}

Taught on Tests.

require

implementation {
	constant scores: List<Integer> = [3, 1, 2]
}

tests {
	test "reads the first score" {
		require scores::hasItems()
		require #Value(first) = scores::firstItem()

		expect first::is(3)
	}
}

Taught on Tests.

across

implementation {
	function isWin(_ scored: Integer, against conceded: Integer) -> Boolean {
		<- scored::isGreaterThan(conceded)
	}
}

tests {
	test "{scored}–{conceded} is a win" across [
		{ scored = 2, conceded = 0 },
		{ scored = 3, conceded = 1 },
	] ({ scored, conceded }: { scored: Integer, conceded: Integer }) {
		expect isWin(scored, against conceded)
	}
}

Taught on Tests.

for any

implementation {
	function double(_ value: Integer) -> Integer {
		<- value::multiply(with 2)
	}
}

tests {
	test "a double is even" for any (value: Integer) {
		expect double(value)::isEven()
	}
}

Taught on Tests.

matches snapshot

implementation {
	constant scores = [3, 1, 2]
}

tests {
	test "sorts the scores" {
		expect scores::sort() matches snapshot "[1, 2, 3]"
	}
}

Taught on Tests.

Modifiers

implementation {
	constant limit = 10
}

tests {
	test "is quick" tagged fast {
		expect limit::isPositive()
	}

	test "waits on a fix" skipped "the parser change" {
		expect limit::is(0)
	}
}

Taught on Tests.

Words that are not keywords

Many of the words the forms above are written with are also ordinary names. Only a short list is reserved.

implementation {
	constant case   = 1
	constant where  = 2
	constant across = 3
	constant trip   = { from = "Oslo", to = "Rome" }

	Terminal.print(case::add(where)::add(across)) § 6
	Terminal.print(trip.from) § Oslo
}

A record may therefore have a member named from or test, and a library method may take a where label, as everyItem(where:) does. for is reserved; it appears in namespace Name for Type and in for any. start and complete are read as keywords only where an expression follows them on the same line, which is the rule under start and complete read the rest of the line.

Where whitespace matters

Most line breaks and all indentation carry no meaning: a statement ends where the grammar says it does, and essence format decides the layout. The seven rules below depend on how tokens sit next to each other.

A label sits in front of its value

A label and its value are separated by a space, never by : or =. slice(from: 1, to: 3) is a syntax error, Expected an Expression but found ':'. Inside an argument list, any word followed by a value reads as a label — with the space. Written flush, a #, a . and a [ carry the name on instead: Choice#Case and order.isPaid are one value each, and primes[0] is an index, refused as foreign-syntax. So append(contentsOf [4]) passes a list and append(contentsOf[4]) does not. The labels entry runs the spelling that works.

A fraction is one token

Digits, / and digits written flush are one Rational literal. The same goes for _ between digits and for the point of a decimal. Terminal.print(3 / 4) is operator-not-supported, Essence has no '/' operator, and 3/n is a syntax error, Expected a Number but found 'n'. The / fraction entry runs it.

:: leads a broken chain

implementation {
	constant total = [1, 2, 3, 4]
		::everyItem(where (n) { <- n::isEven() })
		::map((n) { <- n::multiply(with n) })
		::sum()

	Terminal.print(total) § 20
}

A chain can break before any ::, and the line that starts with :: continues the expression above it. A break after the :: parses too. When essence format breaks a chain, it puts each :: at the start of its line, one step in; a chain that fits is joined onto one line.

No ( after if

An if condition takes no parentheses. A ( in an expression starts a function literal’s parameter list, so if (count::isEven()) { is a syntax error, Expected a Type but found ':'. if (ready) { is Expected '{' but found '}', and if (count > 3) { is Expected ')' but found '>'. The if entry runs the spelling without them.

A space between a label and #

round(toward #Down) is the label toward and the bare case #Down. Written flush, toward#Down reads as the case Down of a choice named toward, and the compiler reports two errors: no-matching-overload on the call, then unknown-type, Type 'toward' is not declared. The flush form is right for naming a case with its choice, Ordering#Less. The # case entry runs both spellings.

start and complete read the rest of the line

Each is a keyword where an expression follows it on the same line, and an ordinary name everywhere else. constant start = 1 binds a constant, span.start reads a member, f(start, other) passes two names, and constant held = start with a statement under it is two statements, because an operand has to begin on the keyword’s own line. Two things cost. An argument label can not be spelled start or complete — f(start x) is the keyword and its operand, and a parameter declared with that label is reserved-parameter-label. And a contextual word behind a value of either name is read as the operand: expect complete matches snapshot waits for a value called matches. The start and complete entries run both readings.

- only before a number

- belongs to a number literal. In front of a name it is operator-not-supported, Essence has no '-' operator, and so is a - between two numbers: constant difference = 10 - 4 is refused rather than read as 10 and -4. An operator is only found where the expression in front of it ended on the same line, so a statement that opens on the next line with -4 is still a signed literal. The - minus entry runs a signed literal.

What there is no syntax for

Decimal numbers exist and are exact; see Literals. A literal can not mix the two spellings: 1/2.5 is mixed-rational-literal. A decimal needs digits on both sides of its point, so 1. and .5 are partial-decimal-literal.

What the compiler prints for each JavaScript habit is on Coming from JavaScript.