ballerina/lang.table Ballerina library

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

table<record {|int id; int math; int physics;|}> students = table [
    {id: 1, math: 78, physics: 70},
    {id: 2, math: 83, physics: 80}
];
students.map(student => {id: student.id, avg: (student.math + student.physics) / 2}) ⇒ [{"id":1,"avg":74},{"id":2,"avg":81}]

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.

table<record {|int id; string name;|}> employees = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
employees.add({id: 1, name: "Pat"});
employees ⇒ [{"id":1,"name":"Jo"},{"id":2,"name":"Sam"},{"id":1,"name":"Pat"}]
table<record {|readonly int id; string name;|}> key(id) students = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
students.add({id: 3, name: "Pat"});
students ⇒ [{"id":1,"name":"Jo"},{"id":2,"name":"Sam"},{"id":3,"name":"Pat"}]
students.add({id: 1, name: "James"}) ⇒ panic
table<record {readonly int id;}> key(id) studentIds = students;
studentIds.add({id: 7}) ⇒ panic

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

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

table<record {|int id; int salary;|}> employees = table [
    {id: 1, salary: 1200},
    {id: 2, salary: 1100},
    {id: 3, salary: 800}
];
employees.filter(emp => emp.salary < 1000) ⇒ [{"id":3,"salary":800}]

Applies a function to each member of a table.

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

table<record {|string name; int salary;|}> employees = table [
    {name: "Jo", salary: 1200},
    {name: "Emma", salary: 800}
];
int total = 0;
employees.forEach(function(record {|string name; int salary;|} emp) {
    total += emp.salary;
});
total ⇒ 2000

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.

table<record {|readonly string index; string name;|}> key(index) students = table [
    {index: "220001CS", name: "Jo"},
    {index: "220002CS", name: "Sam"}
];
students.get("220002CS") ⇒ {"index":"220002CS","name":"Sam"}
students.get("110002CS") ⇒ panic

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

table<record {|readonly int id; string name;|}> key(id) students = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
students.hasKey(1) ⇒ true
students.hasKey(5) ⇒ false

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.

object {
    public isolated function next() returns record {|record {|string name;|} value;|}?;
} iterator = table [
    {name: "Jo"},
    {name: "Smith"}
].iterator();
iterator.next() ⇒ {"value":{"name":"Jo"}}

Returns a list of all the keys of a table.

table<record {|readonly string code; string name;|}> key(code) countries = table [
    {code: "CAN", name: "Canada"},
    {code: "DNK", name: "Denmark"},
    {code: "NPL", name: "Nepal"}
];
countries.keys() ⇒ ["CAN","DNK","NPL"]

Returns number of members of a table.

table<record {|string name;|}> students = table [
    {name: "Jo"},
    {name: "Smith"}
];
students.length() ⇒ 2

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

table<record {|readonly int id; string name;|}> key(id) users = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
users.nextKey() ⇒ 3

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.

table<record {|int id; string name;|}> employees = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
employees.put({id: 1, name: "Pat"});
employees ⇒ [{"id":1,"name":"Jo"},{"id":2,"name":"Sam"},{"id":1,"name":"Pat"}]
table<record {|readonly int id; string name;|}> key(id) students = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
students.put({id: 3, name: "Pat"});
students ⇒ [{"id":1,"name":"Jo"},{"id":2,"name":"Sam"},{"id":3,"name":"Pat"}]
students.put({id: 1, name: "Kane"});
students ⇒ [{"id":1,"name":"Kane"},{"id":2,"name":"Sam"},{"id":3,"name":"Pat"}]
table<record {readonly int id;}> key(id) studentIds = students;
studentIds.put({id: 7}) ⇒ panic

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.

table<record {int id; int salary;}> employees = table [
    {id: 1, salary: 1200},
    {id: 2, salary: 1100},
    {id: 3, salary: 800}
];
employees.reduce(isolated function (int total, record {int id; int salary;} next) returns int => total + next.salary, 0) ⇒ 3100

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.

table<record {|readonly int id; string name;|}> key(id) students = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
students.remove(1) ⇒ {"id":1,"name":"Jo"}
students ⇒ [{"id":2,"name":"Sam"}]
students.remove(5) ⇒ panic

Removes all members of a table.

This panics if any member cannot be removed.

table<record {|string name;|}> students = table [
    {name: "Jo"},
    {name: "Sam"}
];
students.removeAll() is () ⇒ true
students ⇒ []
table<record {|int score;|}> scores = <readonly> table [
    {score: 30},
    {score: 40}
];
scores.removeAll() ⇒ panic

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 ().

table<record {|readonly int id; string name;|}> key(id) students = table [
    {id: 1, name: "Jo"},
    {id: 2, name: "Sam"}
];
students.removeIfHasKey(1) ⇒ {"id":1,"name":"Jo"}
students ⇒ [{"id":2,"name":"Sam"}]
students.removeIfHasKey(3) is () ⇒ true

Returns a list of all the members of a table.

table [
    {code: "CAN", name: "Canada"},
    {code: "DNK", name: "Denmark"},
    {code: "NPL", name: "Nepal"}
].toArray() ⇒ [{"code":"CAN","name":"Canada"},{"code":"DNK","name":"Denmark"},{"code":"NPL","name":"Nepal"}]