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: string = "Hello, Zeus!";
let emoji: string = "Welcome 👋";
let japanese: string = "こんにちは";

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

function main(): void {
  log("Line 1\nLine 2");     // Two lines
  log("Col1\tCol2\tCol3");   // Tab-separated
  log("Say \"Hello\"");      // Embedded quotes
  log("Path: C:\\Users");    // Backslash
}

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';

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

// To log bytes, convert back to string
let modified: string = bytes;
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: string = "Hello";
let len: i32 = text.length;  // 5

let emoji: string = "👋";
let emojiLen: i32 = 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: string = "apple";
let b: string = "banana";
let c: string = "apple";

let cmp1: i8 = a.compare(b);  // -1 (apple < banana)
let cmp2: i8 = b.compare(a);  // 1  (banana > apple)
let cmp3: i8 = 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: string = "Hello";
let world: string = "World";

let greeting: string = hello.concat(" ").concat(world);
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: string = "Hello";
let second: string = "World";
let result: string = first + " " + second;
log(result);  // "Hello World"

Equality Operators (== and !=)

Compare strings for equality or inequality:

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

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

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

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

Compare strings lexicographically (dictionary order):

let apple: string = "apple";
let banana: string = "banana";

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

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

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

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

if (a >= b) {
  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[]:

function main(): void {
  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;
  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: string = "A";
let asciiLen: i32 = ascii.length;  // 1

let emoji: string = "👋";
let emojiLen: i32 = emoji.length;  // 4

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
• String interpolation (${expression})
• Character iteration

---

Next

Arrays →