Primitive types

As explained in the previous chapter, primitive types can only store their value. Typically they use from 1 to 8 bytes of memory each.

Boolean

The boolean type represents logical values and can only be true or false. Booleans are commonly used in conditional statements and logical operations.

main = {
	isActive: bool = true
	hasPermission: bool = false
	println(isActive)
	println(hasPermission)
}

The code above can be read as:

"Declare a variable called isActive of type bool with value true, and declare a variable called hasPermission of type bool with value false"

Byte

The byte type stores small integer values ranging from -128 to 127. It uses 1 byte of memory and is useful for efficient storage when working with small numbers.

main = {
	A: byte = 65b
	Z: byte = 90b
	println(A)
	println(Z)
}

The code above can be read as:

"Declare a variable called A of type byte with value 65, and declare a variable called B of type byte with value 90"

Since zen treats bytes as characters their output will be the letters A and Z respectively, in the next chapters you will learn how to convert them to integers and print their numeric value.

Short

The short type stores medium-sized integer values ranging from -32,768 to 32,767. It uses 2 bytes of memory and provides a balance between range and memory efficiency.

main = {
	year: short = 2025s
	elevation: short = 1500s
	println(year)
	println(elevation)
}

The code above can be read as:

"Declare a variable called year of type short with value 2025, and declare a variable called elevation of type short with value 1500"

Integer

The int type stores standard integer values ranging from approximately -2 billion to 2 billion. It uses 4 bytes of memory and is the most commonly used type for whole numbers.

main = {
	population: int = 1500000
	distance: int = -250i
	println(population)
	println(distance)
}

The code above can be read as:

"Declare a variable called population of type int with value 1,500,000, and declare a variable called distance of type int with value -250"

Long

The long type stores large integer values ranging from approximately -9 quintillion to 9 quintillion. It uses 8 bytes of memory and is ideal for very large whole numbers.

main = {
	nationalDebt: long = 35_000_000_000_000l
	timestamp: long = 1_699_804_800_000l
	println(nationalDebt)
	println(timestamp)
}

The code above can be read as:

"Declare a variable called nationalDebt of type long with value 35 trillion, and declare a variable called timestamp of type long with value 1699804800000"

Float

The float type stores decimal numbers with single precision. It uses 4 bytes of memory and provides approximately 7 decimal digits of precision.

main = {
	price: float = 19.99f
	temperature: float = 36.6f
	println(price)
	println(temperature)
}

The code above can be read as:

"Declare a variable called price of type float with value 19.99, and declare a variable called temperature of type float with value 36.6"

Double

The double type stores decimal numbers with double precision. It uses 8 bytes of memory and provides approximately 15 decimal digits of precision, making it suitable for scientific calculations.

main = {
	pi: double = 3.14159265359
	scientificConstant: double = 6.022e23d
	println(pi)
	println(scientificConstant)
}

The code above can be read as:

"Declare a variable called pi of type double with value 3.14159265359, and declare a variable called scientificConstant of type double with value 6.022×10²³"

Type comparison

Here's a summary of all primitive types in Zen:

---

Activities

Choose the Right Type

Pick the best type for each variable:

main = {
    // 1. Is the store open? (true/false)
    storeOpen: ??? = true
    
    // 2. Letter grade 'A' 
    grade: ??? = 65b
    
    // 3. Year 2025
    year: ??? = 2025s
    
    // 4. Population 500,000
    population: ??? = 500000
    
    // 5. World population 8,000,000,000
    worldPopulation: ??? = 8000000000l
    
    // 6. Price $19.99
    price: ??? = 19.99f
    
    // 7. Pi to 10 decimals
    pi: ??? = 3.1415926535
}

Fix the Errors

Each line has a type/value mismatch. Fix them:

main = {
    age: byte = 150           // byte max is 127
    year: short = 50000       // short max is 32,767
    huge: int = 10000000000   // int max is ~2 billion
}

Add the Suffixes

Add the correct suffix (b, s, l, f, d) where needed:

main = {
    a: byte = 100
    b: short = 2024
    c: long = 999999999
    d: float = 3.14
    
    println(a)
    println(b)
    println(c)
    println(d)
}

Big Numbers

Write these using scientific notation:

main = {
    // 1. Speed of light: 300,000,000 m/s
    c: double = ???
    
    // 2. One trillion
    trillion: double = ???
    
    println(c)
    println(trillion)
}

Hint: 1e6 = 1,000,000

Memory Quiz

• Which uses more memory: int or short?
• How many bytes does double use?
• Which is bigger: float or double?
• What's the smallest integer type?