Ownership and Mutability in Sifr

Sifr gives you Rust’s memory-safety guarantees without making every call site look like Rust. Function parameters borrow by default, parameter mutation is explicit, and ownership transfer is opt-in. Most code starts with a plain parameter and reaches for mut, own, or own mut only when the function’s contract needs it.

Parameter Conventions

Parameter style	Meaning	Caller keeps value?	Callee can mutate?
`items: list[int]`	Immutable borrow	Yes	No
`mut items: list[int]`	Mutable borrow	Yes	Yes, during the call
`own items: list[int]`	Owned immutable binding	No	No, unless copied into a mutable local
`own mut items: list[int]`	Owned mutable binding	No	Yes

This table is the core model. A bare heap parameter is borrowed immutably. mut lets the function update the caller’s value during the call. own moves the value into the function. own mut moves it and lets the function change it. The same conventions apply to class methods. In particular, a bare move-only method parameter is borrowed and cannot be returned or stored as an owned value; spell it own when the method intentionally consumes it.

Borrow By Default

When you pass a heap value to a function, Sifr borrows it by default. The function can read the value, and the caller keeps ownership.

def get_length(items: list[int]) -> int:
    return len(items)

def main():
    values: list[int] = [10, 20, 30]
    length: int = get_length(values)
    print(length)
    print(values)  # still usable

Bare parameters are immutable. The callee cannot reassign the parameter name or mutate the object behind it.

def count_items(items: list[int]) -> int:
    # items.append(0) would be rejected
    return len(items)

`mut` For Mutable Borrows

Use mut when the function should update the caller’s value in place.

def append_all(mut target: list[bool], values: list[bool]) -> None:
    for value in values:
        target.append(value)

def main():
    checks: list[bool] = []
    append_all(checks, [True, False])
    print(checks)  # [True, False]

mut is required both for rebinding a parameter name and for mutating through a heap parameter. Rebinding a mutable borrowed parameter to another value still does not make the borrowed value owned.

A mutable borrow cannot escape. mut items: list[int] can update the caller’s list during the call, but it cannot return items or store it as an owned value. Use own, own mut, or items.clone() depending on whether the function should consume, mutate, or copy the value.

`own` And `own mut`

Use own when a function consumes a value. After the call, the caller cannot use the moved value.

def consume_and_count(own items: list[int]) -> int:
    return len(items)

def main():
    values: list[int] = [1, 2, 3]
    count: int = consume_and_count(values)
    print(count)
    # values is moved here

Use own mut when the function consumes a value and needs to mutate it.

def append_zero(own mut values: list[int]) -> list[int]:
    values.append(0)
    return values

def main():
    updated: list[int] = append_zero([2, 3, 4])
    print(updated)  # [2, 3, 4, 0]

own mut is the canonical spelling. The formatter rewrites mut own to own mut.

Scalars And Immutable Values

Scalar values such as int, float, and bool behave like ordinary values at the source level. A mut n: int parameter permits local rebinding inside the function, but it does not create an observable heap borrow or ownership transfer.

def increment(mut n: int) -> int:
    n = n + 1
    return n

Some types are immutable by design. For example, mut does not make bytes subscript assignment legal.

Across `await`

Mutable borrows cannot remain live across an await point. End the mutation before awaiting, move owned data into a task, or wrap shared state in an explicit synchronization primitive.

def append_before_await(mut items: list[int]) -> None:
    items.append(1)

async def main() -> None:
    values: list[int] = []
    append_before_await(values)
    await task.sleep(0.0)

For the task-boundary model, see Concurrency.

Rules At A Glance

Need	Use
Read a value without taking it	`items: list[int]`
Update the caller’s value during the call	`mut items: list[int]`
Consume a value	`own items: list[int]`
Consume and mutate a value	`own mut items: list[int]`
Keep a borrowed value after the call	`.clone()` or change the boundary to `own`

Coming from Python?

Follow a path through mutation, typed errors, imports, and packages.

Coming from Rust?

Map mut, own, and borrow-by-default rules back to Rust concepts.

Get Started

Learn Sifr

CLI

Package Management

Standard Library

Concurrency

Error Codes

Ownership and Mutability in Sifr

Parameter Conventions

Borrow By Default

`mut` For Mutable Borrows

`own` And `own mut`

Scalars And Immutable Values

Across `await`

Rules At A Glance

Coming from Python?

Coming from Rust?

​Parameter Conventions

​Borrow By Default

​mut For Mutable Borrows

​own And own mut

​Scalars And Immutable Values

​Across await

​Rules At A Glance

Coming from Python?

Coming from Rust?

Parameter Conventions

Borrow By Default

`mut` For Mutable Borrows

`own` And `own mut`

Scalars And Immutable Values

Across `await`

Rules At A Glance