## Module overview

The `lang.table` module corresponds to the `table` basic type.


Applies a function to each member of a table and returns a table of the result.



'map

table<MapType> 

func

MapType

MapType1

new table containing result of applying parameter `func` to each member


table<MapType1> key<never> 

Adds a member to a table.

It will be added as the last member.
It panics if parameter `val` has the same key as an existing member of parameter `t`,
or if parameter `val` is inconsistent with the inherent type of `t`.



Selects the members from a table for which a function returns true.

The resulting table will have the same keys as the argument table.



filter

table<MapType> key<KeyType> 

a predicate to apply to each member to test whether it should be included


boolean

new table containing members for which parameter `func` evaluates to true


Applies a function to each member of a table.

The parameter `func` is applied to each member of parameter `t`.



forEach

Returns the member of an table with a particular key.

This for use in a case where it is known that the table has a specific key,
and accordingly panics if parameter `t` does not have a member with key parameter `k`.



KeyType

Tests whether a table has a member with a particular key.



hasKey

true if parameter `t` has a member with key parameter `k`


Returns an iterator over a table.

The iterator will iterate over the members of the table not the keys.
The `entries` function can be used to iterate over the keys and members together.
The `keys` function can be used to iterator over just the keys.



iterator

a new iterator object that will iterate over the members of parameter `t`


object {
    public isolated function next() returns record {|
        MapType value;
    |}?;
} 

Returns a list of all the keys of a table.



keys

table<map<any|error>> key<KeyType> 

length

table<map<any|error>> 

Returns the next available integer key.

This is maximum used key value + 1, or 0 if no key used
XXX should it be 0, if the maximum used key value is < 0?
Provides similar functionality to auto-increment



nextKey

table<MapType> key<int> 

Adds a member to a table value, replacing any member with the same key value.

If parameter `val` replaces an existing member, it will have the same position
in the order of the members as the existing member;
otherwise, it will be added as the last member.
It panics if parameter `val` is inconsistent with the inherent type of parameter `t`.



Combines the members of a table using a combining function.

The combining function takes the combined value so far and a member of the table,
and returns a new combined value.



reduce

Type

initial value for the first argument of combining parameter `func`


initial

error

result of combining the members of parameter `t` using parameter `func`


Removes a member of a table.

This removed the member of parameter `t` with key parameter `k` and returns it.
It panics if there is no such member.



remove

the member of parameter `t` that had key parameter `k`


Removes all members of a table.

This panics if any member cannot be removed.



removeAll

Removes a member of a table with a given key, if the table has member with the key.

If parameter `t` has a member with key parameter `k`, it removes and returns it;
otherwise it returns `()`.



removeIfHasKey

the member of parameter `t` that had key parameter `k`, or `()` if parameter `t` does not have a key parameter `k`


Returns a list of all the members of a table.



toArray

an array whose members are the members of parameter `t`


The `lang.table` module corresponds to the `table` basic type.


A type parameter that is a subtype of `anydata`.
Has the special semantic that when used in a declaration
all uses in the declaration must refer to same type.


anydata

A type parameter that is a subtype of `any|error`.
Has the special semantic that when used in a declaration
all uses in the declaration must refer to same type.


Types