Lists and tuples

Lynxer has two sequence types: list (built with [...]) and tuple (built with (...)). Both use value semantics — see below — and share a large family of builtins.

Value semantics

A list or tuple is copied on assignment, and no list builtin mutates its argument. The collection builtins return a new value that you assign back:

list xs = [1, 2, 3];
xs = listPush(xs, 4);     // listPush returns a new list; assign it back
list ys = xs;             // ys is a copy
xs = listSet(xs, 0, 9);
println(ys);              // [1, 2, 3, 4]  (unchanged)

listPush(xs, 4); on its own discards the result and leaves xs unchanged. The same is true of sortList, reverseList, listExtend, listInsert, listRemove, listSet and listClear: each returns a new list.

The one exception is listPop(list), which returns the element it removed and leaves the list unchanged:

list xs = [1, 2, 3];
println(listPop(xs));   // 3
println(xs);            // [1, 2, 3]

Indexing

Indices are zero-based and may be negative (-1 is the last element). An index outside the list is a source-located error, for example listGet() index -5 out of range for list of length 3.

list xs = [1, 2, 3];
println(listGet(xs, 0));    // 1
println(listGet(xs, -1));   // 3
println(listSlice(xs, 1, 3));  // [2, 3]  (start inclusive, end exclusive)

Typed element literals

An element may be prefixed with a type, which is validated:

list nums = [int 1, int 2];
tuple pair = (int 10, int 20);

Creating Sequences

Lists

Tuples

Conversions

List builtins

Tuple Builtins

Notes

• Tuples are immutable: Operations like tupleConcat and tupleSlice return a new tuple.
• Iteration: Use tupleToList() to iterate over a tuple with a for loop or index manually.
• Conversions: Use listToTuple() and tupleToList() to convert between lists and tuples.
• Full tuple reference: tuples covers declaration forms, comparison, iteration, and differences from the original.

The length of a list, tuple, or string is returnLength(value), and contains(container, value) tests membership for both lists and tuples.

Tuple Builtins

Typing Module Functions

The typing module provides additional tuple functions:

Note: These functions require importing the typing module (import("typing")).

There is no tupleSet; use a list when you need to replace elements.

Example

global setup(){}

global main(){
    list xs = [1, 2, 3];
    xs = listPush(xs, 4);
    println(xs);                 // [1, 2, 3, 4]
    println(listGet(xs, -1));    // 4
    println(contains(xs, 9));    // false

    list ys = xs;                // a copy
    xs = listSet(xs, 0, 9);
    println(ys);                 // [1, 2, 3, 4]

    tuple pair = (10, 20);
    println(tupleGet(pair, 1));  // 20
    println(returnLength(pair)); // 2
}

See builtins for the full builtin reference and types for how list and tuple behave as declared types.