Value Types

By default, variables in Sric are value types that get automatically copied during assignment/passing. Pointer types only copy the pointer itself, not the pointed-to object.

Pointers

  • Three pointer types: owning, non-owning, and raw
  • Asterisk placement differs from C/C++ (before type)
var p: Int             // Value type
var p: own* Int;       // Owning pointer
var p: * Int;          // Non-owning pointer
var p: & Int;          // Reference
var p: raw* Int;       // Raw pointer
var p: uniq* Int;      // Unique pointer

Sric also provides C++-style smart pointers (SharedPtr, WeakPtr) via standard library.

Memory Allocation

Get pointers via address-of operator or new:

var i: own* Int = new Int;  // Parentheses omitted (no constructors)

Owning Pointers

  • Own their objects (auto-released at scope exit)
  • Require explicit move/copy during transfer:
var p1: own* Int = ...;
var p2 = move p1;          // Transfer ownership
var p3 = share(p1);        // Shared ownership

Unique Pointers

uniq* is zero-overhead. Similar to own*, but without a share() method.

var p1: uniq* Int = makeUniq$<T>();
var p2 = move p1;

Non-owning Pointers

  • No borrowing restrictions like Rust
  • Runtime validity checks
  • Implicit conversion from own*/uniq*:
var p1: own* Int = ...;
var p4: * Int = p1;       // Non-owning
var p5: raw* Int = p1;    // Raw

Raw Pointers

  • C/C++-style pointers (require unsafe):
var p: raw* Int = ...;
unsafe {
    var i = *p;
}

Address-of Operator

Get pointers from values (non-owning by default):

var i: Int = 0;
var p: *Int = &i;

Pointer Arithmetic

Only allowed for raw pointers in unsafe contexts:

var p : raw* Int = ...;
unsafe {
    ++p;
    p = p + 2;
}

References

Similar to C++ but restricted to function parameters/returns:

fun foo(a: & const Int) {}  // Auto-dereferencing

Arrays

Fixed-size arrays (for dynamic arrays see DArray):

var a: [5]Int;                // Explicit size
var a = []Int { 1,3,4 };      // Size inference
constexpr var size = 15;
var a: [size]Int;             // Constexpr size

Null Safety

Pointers are non-nullable by default (use ? for nullable):

var a: own*? B = null;     // Valid
var a: own* B = null;      // Compile error

Immutability

const can modify either pointer or pointee:

var p : raw* const Int;     // Immutable value
var p : const raw* Int;     // Immutable pointer
var p : const raw* const Int;  // Both