Methods🔗

Bop dispatches methods with .name(args...). Every built-in method on primitives, arrays, strings, and dicts is listed here. User-defined methods on structs use the same syntax — see Structs & Enums for the fn Type.method(self, ...) form.

Methods on every value🔗

Three methods work on any value — introspection + stringification. They’re dispatched before the type-specific tables, so they’re always available:

print((42).type())                 // "int"
print("hi".to_str())               // "hi"
print("hi".inspect())              // "hi"   (quoted)
print([1, "two"].inspect())        // [1, "two"]

print(none.is_none())              // true
print((0).is_none())               // false — `0` is falsy but not `none`
print(first_result().is_some())    // check an optional return without `== none`

.is_none() / .is_some() cover Bop’s “any variable can be none” story — they work on every receiver, not just Option-shaped ones (Bop doesn’t have Option). Equivalent to x == none / x != none, but reads better in method chains.

Parens around numeric literals🔗

Number literals need parens before a method call because . is otherwise a decimal point:

// print(42.type())   // parse error — `42.t…` looks like a decimal
print((42).type())     // "int"
print((-5).abs())      // 5

Identifiers don’t have this problem: x.type(), count.to_str(), etc.

Numeric methods — int and number🔗

All of these work on both int and number receivers. Return type is noted per method; most math operations always widen to number.

print((9).sqrt())                   // 3
print((0).cos())                    // 1
print((2).pow(10))                  // 1024
print((3).min(7))                   // 3
print((1).max(2.5))                 // 2.5   (widened)
print((3.7).floor())                // 3     (int)
print((3.7).floor().type())         // "int"

Boolean methods — bool🔗

Plus the universal type / to_str / inspect.

String methods — string🔗

See Strings for worked examples.

Array methods — array🔗

See Arrays for worked examples.

Mutating methods write back when the receiver is a variable (items.push(x)). Calling one on a genuine temporary, such as [1].push(2) or make_items().pop(), is legal; the temporary is mutated and then discarded. An index or field read is not yet a write-back place, so dict["items"].push(x) and holder.items.pop() raise a runtime error instead of silently losing the mutation. Assign the nested array to a variable first, then explicitly store it back when needed.

Dict methods — dict🔗

See Dictionaries for worked examples.

Result methods — Result🔗

Result is an engine built-in. All combinators are methods on the built-in type — no import required. Ok(x) and Err(e) are parser-level shorthand for Result::Ok(x) / Result::Err(e) in both expression and pattern position.

print(Ok(5).is_ok())                           // true
print(Err("bad").unwrap_or(0))                 // 0
print(Ok(5).map(fn(v) { return v * 2 }))       // Result::Ok(10)
print(Err("x").map(fn(v) { return v * 2 }))    // Result::Err("x")

fn halve(x) {
  if x % 2 == 0 { return Ok((x / 2).to_int()) }
  return Err("odd")
}
print(Ok(8).and_then(halve).and_then(halve))   // Result::Ok(2)

Iter methods — iter🔗

An iter is Bop’s lazy iterator. Values you can iterate over — arrays, strings, dicts, built-in iterators, and user-defined containers — all participate in the same protocol:

1. v.iter() returns an iterator.
2. it.next() advances it, returning Iter::Next(value) or Iter::Done.

for x in v uses this protocol, so anything with a working .iter() method works with for.

let it = [10, 20, 30].iter()
print(it.type())                // "iter"
print(it.next())                // Iter::Next(10)
print(it.next())                // Iter::Next(20)

for x in it { print(x) }        // 30  (picks up from the current cursor)

User-defined iterables🔗

A struct can participate in the iterator protocol by implementing .iter() (and, if it’s its own iterator, .next()):

struct Bag { items }
fn bag_of(arr) { return Bag { items: arr } }
fn Bag.iter(self) { return self.items.iter() }   // delegate to the backing array

let b = bag_of(["x", "y", "z"])
for v in b { print(v) }                           // x  y  z

That’s the minimal shape. A container that wraps an array and delegates .iter() is the 80% case. User types with genuine internal state (like a lazy counter) work the same way — define fn Counter.iter(self) to return an iterator (either the backing data’s iterator, or self if self also has .next()).

The Iter enum🔗

.next() returns one of two variants of the built-in Iter enum — always in scope, no use required:

enum Iter {
  Next(value),
  Done,
}

Pattern-match directly:

let it = [1, 2].iter()
let r = it.next()
print(match r {
  Iter::Next(v) => "got: " + v.to_str(),
  Iter::Done    => "exhausted",
})
// got: 1

Struct / enum methods🔗

User-declared. See Structs & Enums. Method dispatch on a struct tries the universal common methods first, then looks up fn TypeName.method declared in the same module.

Same-module rule: user-declared methods must live in the module that declares the type. You can’t extend a type imported from another module, and you can’t add methods to the built-ins (int, string, array, Result, Iter, …). See Methods must live in the type’s own module for the rationale and the “use a free function instead” workaround.

Module methods🔗

If you use path as m, m is a Value::Module. m.type() → "module", m.inspect() → "<module path>". Otherwise . on a module accesses its exports:

use std.math as m
print(m.PI)             // exported constant
print(m.type())         // "module"   (universal method, not an export)