Variables & Data Types

Chuks provides strictly typed data containers with type inference support.

Variables and Constants

// Mutable variable with explicit type
var age: int = 25;

// Mutable variable with type inference
var name = "Alice";

// Immutable constant
const PI = 3.14159;

// Constants must be initialized and cannot be reassigned
const MAX_SIZE: int = 100;

Basic Data Types

Chuks provides a comprehensive set of data types for precise memory and performance control.

Category	Types	Description	Example
Integers	int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, byte, rune	Signed & unsigned whole numbers	42, -7, 0
Floats	float, float32, float64	Floating-point numbers	3.14, -0.5
Complex	complex64, complex128	Complex numbers	1 + 2i
String	string	Text strings (UTF-8)	"hello", "world"
Boolean	bool	Boolean values	true, false
Dynamic	any	Dynamic type (use sparingly)	Any value
Void	void	No return value	Used in signatures
Null	null	Absence of value	null

Numeric Literals

In addition to standard decimal integers and floats, Chuks supports hexadecimal, octal, and binary integer literals.

Prefix	Base	Digits	Example	Decimal Value
0x	Hexadecimal	0-9, a-f	0xFF	255
0o	Octal	0-7	0o77	63
0b	Binary	0-1	0b1010	10

// Hexadecimal (base 16)
var hex = 0xFF;           // 255
var color = 0xABCD;       // 43981
var lower = 0xff;         // 255 (lowercase also accepted)

// Octal (base 8)
var perm = 0o755;         // 493
var oct = 0o77;           // 63

// Binary (base 2)
var flags = 0b1010;       // 10
var byte_val = 0b11111111; // 255
var bit = 0b10000000;     // 128

All numeric literal forms work seamlessly in arithmetic and bitwise expressions:

println(0xFF + 1);               // 256
println(0o10 * 2);               // 16
println(0b1010 - 5);             // 5
println(0xFF & 0x0F);            // 15  (bitwise AND)
println(0b11110000 | 0b00001111); // 255 (bitwise OR)

You can store them in typed variables just like any other integer:

var hex: int = 0xCAFE;    // 51966
var oct: int = 0o644;     // 420
var bin: int = 0b10101010; // 170

Note

Hex, octal, and binary literals are integer-only. Floating-point values must use decimal notation.

Collections

For detailed documentation on collection types, see:

• Strings — Immutable character sequences
• Arrays — Ordered, dynamic collections
• Maps — Key-value pairs

The dataType Construct

dataType is a lightweight structure for grouping data fields. It’s similar to structs in Go or records in TypeScript. Unlike classes, dataType is intended for simple data containers.

Basic Usage

dataType User {
    id: int;
    name: string;
    isActive: bool;
}

// Instantiate using object literal syntax
var u: User = {
    "id": 1,
    "name": "Alice",
    "isActive": true
};

print(u.name); // "Alice"

Generic Data Types

Data types support generics for flexible data structures.

dataType Point<T> {
    x: T;
    y: T;
}

dataType Pair<K, V> {
    first: K;
    second: V;
}

function main() {
    // Point of integers
    var p1: Point<int> = { "x": 10, "y": 20 };

    // Point of strings
    var p2: Point<string> = { "x": "ten", "y": "twenty" };

    // Pair of different types
    var kv: Pair<string, int> = { "first": "age", "second": 30 };

    print(p1.x);        // 10
    print(kv.second);   // 30
}

Constructor-less Initialization

dataType does not have constructors. Instead, you initialize instances using map literals { key: value }. Types are checked against the dataType schema.

Methods (Optional)

While primarily for data, dataType can contain methods if needed.

dataType Vector {
    x: int;
    y: int;

    function magnitude(): float {
        return math.sqrt(this.x * this.x + this.y * this.y);
    }
}

Nullable Types

Nullable types allow a variable to hold either a value of a specific type or null. Append ? to any type to make it nullable.

Basic Usage

var name: string? = "Alice";
name = null;  // Valid — string? accepts null

var age: int? = null;
age = 25;

Function Parameters and Return Types

function findUser(id: int): string? {
    if (id == 1) {
        return "Alice";
    }
    return null;
}

function greet(name: string?): string {
    if (name == null) {
        return "Hello, stranger!";
    }
    return "Hello, " + name;
}

In DataTypes

dataType User {
    id: int;
    name: string?;
    email: string?;
}

var user: User = {
    "id": 1,
    "name": "Alice",
    "email": null
};

In Classes

class UserProfile {
    var name: string;
    var bio: string?;

    constructor(name: string, bio: string?) {
        this.name = name;
        this.bio = bio;
    }
}

var profile = new UserProfile("Alice", null);

In Interfaces

interface UserService {
    findById(id: int): User?;
    getName(id: int): string?;
}

Nullable Arrays

// Array of nullable strings
var tags: []string? = ["hello", null, "world"];

// Nullable array itself
var items: []int? = null;

Note

A non-nullable variable cannot be assigned null. Use T? when a value might be absent.

Type Conversions

Chuks provides Go-style builtin functions for converting between types:

Function	Returns	Description	Example
int(value)	int	Convert to integer (truncates)	int(3.14) → 3
float(value)	float	Convert to float	float(42) → 42.0
string(value)	string	Convert any value to string	string(42) → "42"

Conversion Rules

// Float to int (truncates)
var x: int = int(3.99)       // 3

// Int to float
var y: float = float(42)     // 42.0

// String to int
var z: int = int("123")      // 123

// String to float
var w: float = float("3.14") // 3.14

// Any value to string
var s: string = string(42)     // "42"
var s2: string = string(true)  // "true"

// Boolean conversions
var b1: int = int(true)      // 1
var b2: int = int(false)     // 0
var b3: float = float(true)  // 1.0

Note

toString(value) also exists as a legacy alias for string(value). Prefer string() in new code.

These conversions work in both the VM interpreter and AOT-compiled code.