//! returns: 0
//! Unnamed parameters retain their own reference positions.

/// Read a reference through an optional parameter.
fn read(value: ?&u32) -> u32 {
    let value = value else return 0;
    return *value;
}

/// Copy a reference within one slice element position.
fn copyFirst(out: &mut [?&u32]) {
    let first = out[0];
    set out[1] = first;
}

/// Sum references through a read-only slice parameter.
fn sum(values: &[?&u32]) -> u32 {
    let mut total: u32 = 0;
    for value in values {
        if let value = value {
            set total += *value;
        }
    }
    return total;
}

/// Clear an optional reference through a mutable parameter.
fn clear(out: &mut ?&u32) {
    set *out = nil;
}

/// Select a reference with the shared declared bound.
fn select(first: &'r u32, second: &'r u32, chooseFirst: bool) -> &'r u32 {
    return first if chooseFirst else second;
}

/// Read a selected reference whose input positions have independent bounds.
fn readSelected(first: &u32, second: &u32, chooseFirst: bool) -> u32 {
    return *select(first, second, chooseFirst);
}

@default fn main() -> i32 {
    let value: u32 = 5;
    let other: u32 = 6;
    assert readSelected(&value, &other, true) == 5;
    assert readSelected(&value, &other, false) == 6;
    let mut slots: [?&u32; 2] = [&value, nil];
    assert read(slots[0]) == 5;
    assert read(slots[1]) == 0;
    copyFirst(&mut slots[..]);
    assert sum(&slots[..]) == 10;
    clear(&mut slots[0]);
    assert sum(&slots[..]) == 5;
    return 0;
}
