Strings and Collections

Pluto’s built-in collection types: strings, byte buffers, arrays, maps, and sets. Plus std.collections for functional operations on arrays.

Strings

String literals use double quotes. Concatenation with +. Interpolation with {} inside an f-prefixed string; a plain string never interpolates.

let s = "hello " + "world"
let name = "alice"
print(f"hello {name}")          // hello alice
print(f"{1 + 2}")               // 3
print(f"use {{braces}}")        // use {braces}  (escape with doubling)
print(f"hello {name}")           // hello {name}  (no f prefix: literal braces)

Escape sequences: \n, \r, \t, \\, \"

Indexing returns a one-byte string (read-only; s[0] = "x" is a compile error). Strings are UTF-8 and indexed by byte, so a non-ASCII character such as é spans several indices:

let s = "hello"
print(s[0])                     // h

Iteration yields one-byte strings, so it splits multi-byte (non-ASCII) characters:

for c in "abc" {
    print(c)                    // a, b, c
}

String Methods

to_int() and to_float() return nullable types. Use ? to propagate:

fn parse(s: string) int? {
    let v = s.to_int()?
    return v * 2
}

Method chaining works naturally: " Hello ".trim().to_lower().contains("hello") returns true.

Bytes

The byte type is an unsigned 8-bit integer (0-255). No byte literal – convert from int with .to_byte(). It returns byte? in general (none outside 0..255), but a literal or a value proven in range narrows to a plain byte; .low_byte() keeps the low 8 bits of any int by name.

let b: byte = (0xFF).to_byte()
print(b.to_int())               // 255
print((300).low_byte().to_int()) // 44

Byte ordering is unsigned: (0xFF).to_byte() > (0x7F).to_byte() is true.

Byte Buffers

Create with bytes_new(). Type is bytes. Supports .push(), .len(), indexing (read/write), and iteration.

let mut buf = bytes_new()
buf.push((72).to_byte())
buf.push((105).to_byte())
print(buf.len())                // 2
print(buf[0].to_int())          // 72
buf[0] = (90).to_byte()         // index write

for b in buf {                  // iteration yields byte values
    print(b.to_int())
}

String conversion – roundtrips cleanly:

let buf = "Hello".to_bytes()
let s = buf.to_string()         // "Hello"

Arrays

Literal syntax with type [T]. All elements must have the same type.

let nums = [1, 2, 3]           // [int]
let names = ["a", "b"]         // [string]

Indexing (read and write) and iteration:

let a = [10, 20, 30]
print(a[0])                     // 10
a[1] = 99                       // index write

for x in a {
    print(x)
}

Array Methods

Arrays work as function parameters (fn f(a: [int])) and return values (fn f() [int]).

Maps

Hash maps with typed keys and values. Keys must be hashable: int, float, bool, string, byte, or enum.

let m = Map<string, int> { "a": 1, "b": 2 }
let empty = Map<string, int> {}

print(m["a"])                   // 1
m["c"] = 3                      // insert via index
m["a"] = 99                     // overwrite

Map Methods

Iteration via .keys() or .values():

for k in m.keys() {
    print(f"{k}: {m[k]}")
}

Sets

Unordered collections with unique elements. Same hashable constraint as map keys.

let s = Set<int> { 1, 2, 3 }
let empty = Set<string> {}

Set Methods

Duplicate inserts are silently ignored. Iterate via .to_array():

for x in s.to_array() {
    print(x)
}

std.collections

Functional operations on arrays. Import with import std.collections.

import std.collections

fn main() {
    let nums = [1, 2, 3, 4, 5]
    let doubled = collections.map(nums, (x: int) => x * 2)
    let evens = collections.filter(nums, (x: int) => x % 2 == 0)
    let total = collections.fold(nums, 0, (acc: int, x: int) => acc + x)
}

Function Reference

zip and enumerate return Pair<A, B> (from std.collections) with fields first and second:

import std.collections

fn main() {
    let pairs = collections.enumerate(["alice", "bob"])
    for p in pairs {
        print(f"{p.first}: {p.second}")  // 0: alice, 1: bob
    }
}