Strings

Zeus provides a first-class string type for working with text. Strings are immutable sequences of UTF-8 encoded bytes.

String Literals

String literals are enclosed in double quotes and create string objects:

let greeting = "Hello, Zeus!";
let emoji = "Welcome 👋";
let japanese = "こんにちは";

String literals fully support UTF-8, including multi-byte characters and emojis.

Escape Sequences

String literals support escape sequences for special characters:

Escape	Character
\n	Newline
\t	Tab
\r	Carriage return
\\	Backslash
\"	Double quote
\'	Single quote
\0	Null character
\e	Escape (ESC, 0x1b)
\xHH	Byte from two hex digits (e.g. \x1b)

console.log("Line 1\nLine 2");     // Two lines
console.log("Col1\tCol2\tCol3");   // Tab-separated
console.log("Say \"Hello\"");      // Embedded quotes
console.log("Path: C:\\Users");    // Backslash
console.log("\e[31mred\e[0m");     // ANSI-colored text (see Colors)

Output:

Line 1
Line 2
Col1  Col2  Col3
Say "Hello"
Path: C:\Users

String vs u8[]

Zeus has two ways to work with text:

Type	Mutability	Use Case
string	Immutable	Text that shouldn’t change
u8[]	Mutable	When you need to modify bytes

Creating Strings

// String literal creates an immutable string
let message: string = "Hello";

Converting to Mutable Bytes

When you assign a string to a u8[], Zeus creates a copy of the underlying bytes. This copy is mutable:

let original: string = "Hello";

// Creates a mutable copy of the bytes
let bytes: u8[] = original;

// Modify the copy (original is unchanged)
bytes[0] = 'h';

console.log(original);  // "Hello" (unchanged)

// To log bytes, convert back to string
let modified: string = bytes;
console.log(modified);  // "hello"

Note

Converting between string and u8[] always creates a copy. This ensures strings remain immutable.

Properties

length

Returns the length of the string in bytes (not characters).

let text = "Hello";
let len = text.length;  // 5

let emoji = "👋";
let emojiLen = emoji.length;  // 4 (UTF-8 bytes)

Caution

For multi-byte UTF-8 characters, length returns the byte count, not the character count. The emoji 👋 is 4 bytes in UTF-8.

Methods

compare

Compares two strings lexicographically (byte-by-byte).

compare(other: string): i8

Returns:

• -1 if this string comes before other
• 0 if the strings are equal
• 1 if this string comes after other

let a = "apple";
let b = "banana";
let c = "apple";

let cmp1 = a.compare(b);  // -1 (apple < banana)
let cmp2 = b.compare(a);  // 1  (banana > apple)
let cmp3 = a.compare(c);  // 0  (apple == apple)

equals

Checks if two strings are equal.

equals(other: string): boolean

Returns: true if the strings have the same bytes, false otherwise.

let a: string = "hello";
let b: string = "hello";
let c: string = "world";

if (a.equals(b)) {
  // This executes - strings are equal
}

if (a.equals(c) == false) {
  // This executes - strings are different
}

concat

Concatenates two strings and returns a new string.

concat(other: string): string

Returns: A new string containing both strings joined together.

let hello = "Hello";
let world = "World";

let greeting = hello.concat(" ").concat(world);
console.log(greeting);  // "Hello World"

Tip

You can also use the + operator for string concatenation. See String Operators below.

String Operators

Zeus supports operators for string manipulation and comparison:

Concatenation (+)

The + operator concatenates two strings:

let first = "Hello";
let second = "World";
let result = first + " " + second;
console.log(result);  // "Hello World"

Equality Operators (== and !=)

Compare strings for equality or inequality:

let a = "hello";
let b = "hello";
let c = "world";

if (a == b) {
  console.log("a equals b");  // This executes
}

if (a != c) {
  console.log("a not equals c");  // This executes
}

Comparison Operators (<, >, <=, >=)

Compare strings lexicographically (dictionary order):

let apple = "apple";
let banana = "banana";

if (apple < banana) {
  console.log("apple comes before banana");  // This executes
}

if (banana > apple) {
  console.log("banana comes after apple");  // This executes
}

let a = "hello";
let b = "hello";

if (a <= b) {
  console.log("a <= b");  // This executes (they're equal)
}

if (a >= b) {
  console.log("a >= b");  // This executes (they're equal)
}

Note

String comparison is byte-by-byte, which means it’s case-sensitive and follows ASCII/UTF-8 ordering. Uppercase letters come before lowercase letters (e.g., "Apple" < "apple").

Indexing

You can read individual bytes from a string using indexing:

let greeting: string = "Hello";

let h: u8 = greeting[0];  // 72 ('H')
let e: u8 = greeting[1];  // 101 ('e')
let o: u8 = greeting[4];  // 111 ('o')

Since strings are immutable, you cannot assign to a string index:

let text: string = "Hello";
text[0] = 'h';  // Error: cannot assign to string index: strings are immutable

To modify characters, convert to u8[] first:

let text: string = "Hello";
let bytes: u8[] = text;   // Create mutable copy
bytes[0] = 'h';           // Modify the copy
let modified: string = bytes;  // "hello"

Implicit Conversions

Zeus supports implicit conversion between string and u8[]:

string → u8[]

Creates a mutable copy of the string’s bytes:

let text: string = "Hello";
let bytes: u8[] = text;  // Mutable copy
bytes[0] = 'J';          // Modify the copy

u8[] → string

Creates a new immutable string from the bytes:

let bytes: u8[] = new u8[];
bytes[0] = 'H';
bytes[1] = 'i';

let text: string = bytes;  // Creates immutable string "Hi"

Working with Bytes

Since strings are UTF-8 encoded, you can work with individual bytes through u8[]:

let greeting: string = "Hi!";

// Convert to mutable bytes
let bytes: u8[] = greeting;

// Access individual bytes
let h: u8 = bytes[0];  // 72 ('H')
let i: u8 = bytes[1];  // 105 ('i')
let exclaim: u8 = bytes[2];  // 33 ('!')

// Modify bytes
bytes[0] = 'h';  // lowercase

// Convert back to string for output
let modified: string = bytes;
console.log(modified);  // "hi!"

UTF-8 Encoding

Strings use UTF-8 encoding, where characters can be 1-4 bytes:

Character	Bytes	Example
ASCII	1 byte	'A' = 65
Extended Latin	2 bytes	'é'
CJK	3 bytes	'日'
Emoji	4 bytes	'👋'

let ascii = "A";
let asciiLen = ascii.length;  // 1

let emoji = "👋";
let emojiLen = emoji.length;  // 4

Template String Literals

Template string literals use backticks and ${expression} placeholders to embed string values inline:

let name = "Zeus";
let version = "1.0";

let greeting = `Hello, ${name}!`;         // "Hello, Zeus!"
let info = `${name} v${version}`;         // "Zeus v1.0"
let plain = `no interpolation here`;      // "no interpolation here"

Each ${...} expression must be of type string. Segments are concatenated left-to-right using the same + operator as explicit string concatenation, so all the same type rules apply.

String expressions only

Interpolated expressions must be of type string. To embed a number, convert it to a string first using a method or format it via another string variable.

Future Features

String Interning

String interning (deduplicating identical strings in memory) is planned for a future release. This optimization will reduce memory usage when the same string value appears multiple times.

The following features are planned for future releases:

• Substring extraction
• Search and replace
• Character iteration