From 42ec7286b2d36a9ba22925f816a17cb1cc2aa5ce Mon Sep 17 00:00:00 2001 From: chai Date: Sat, 30 Oct 2021 11:32:16 +0800 Subject: + Penlight --- .../Penlight/docs/libraries/pl.tablex.html | 1980 ++++++++++++++++++++ 1 file changed, 1980 insertions(+) create mode 100644 Data/Libraries/Penlight/docs/libraries/pl.tablex.html (limited to 'Data/Libraries/Penlight/docs/libraries/pl.tablex.html') diff --git a/Data/Libraries/Penlight/docs/libraries/pl.tablex.html b/Data/Libraries/Penlight/docs/libraries/pl.tablex.html new file mode 100644 index 0000000..2e07080 --- /dev/null +++ b/Data/Libraries/Penlight/docs/libraries/pl.tablex.html @@ -0,0 +1,1980 @@ + + + + + Penlight Documentation + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ +

Module pl.tablex

+

Extended operations on Lua tables.

+

See the Guide

+ +

Dependencies: pl.utils, pl.types

+ + +

Functions

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
size (t)total number of elements in this table.
index_by (tbl, idx)return a list of all values in a table indexed by another list.
transform (fun, t, ...)apply a function to all values of a table, in-place.
range (start, finish[, step=1])generate a table of all numbers in a range.
reduce (fun, t, memo)'reduce' a list using a binary function.
index_map (t)create an index map from a list-like table.
makeset (t)create a set from a list-like table.
union (t1, t2)the union of two map-like tables.
intersection (t1, t2)the intersection of two map-like tables.
count_map (t, cmp)A table where the key/values are the values and value counts of the table.
set (t, val[, i1=1[, i2=#t]])set an array range to a value.
new (n, val)create a new array of specified size with initial value.
clear (t, istart)clear out the contents of a table.
removevalues (t, i1, i2)remove a range of values from a table.
readonly (t)modifies a table to be read only.
+

Copying

+ + + + + + + + + + + + + + + + + + + + + + + + + +
update (t1, t2)copy a table into another, in-place.
copy (t)make a shallow copy of a table
deepcopy (t)make a deep copy of a table, recursively copying all the keys and fields.
icopy (dest, src[, idest=1[, isrc=1[, nsrc=#src]]])copy an array into another one, clearing dest after idest+nsrc, if necessary.
move (dest, src[, idest=1[, isrc=1[, nsrc=#src]]])copy an array into another one.
insertvalues (t[, position], values)insert values into a table.
+

Comparing

+ + + + + + + + + + + + + +
deepcompare (t1, t2[, ignore_mt[, eps]])compare two values.
compare (t1, t2, cmp)compare two arrays using a predicate.
compare_no_order (t1, t2, cmp)compare two list-like tables using an optional predicate, without regard for element order.
+

Finding

+ + + + + + + + + + + + + + + + + +
find (t, val, idx)return the index of a value in a list.
rfind (t, val, idx)return the index of a value in a list, searching from the end.
find_if (t, cmp, arg)return the index (or key) of a value in a table using a comparison function.
search (t, value[, exclude])find a value in a table by recursive search.
+

MappingAndFiltering

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
map (fun, t, ...)apply a function to all values of a table.
imap (fun, t, ...)apply a function to all values of a list.
map_named_method (name, t, ...)apply a named method to values from a table.
map2 (fun, t1, t2, ...)apply a function to values from two tables.
imap2 (fun, t1, t2, ...)apply a function to values from two arrays.
mapn (fun, ..., fun)Apply a function to a number of tables.
pairmap (fun, t, ...)call the function with the key and value pairs from a table.
filter (t, pred, arg)filter an array's values using a predicate function
+

Iterating

+ + + + + + + + + + + + + + + + + +
foreach (t, fun, ...)apply a function to all elements of a table.
foreachi (t, fun, ...)apply a function to all elements of a list-like table in order.
sort (t, f)return an iterator to a table sorted by its keys
sortv (t, f)return an iterator to a table sorted by its values
+

Extraction

+ + + + + + + + + + + + + +
keys (t)return all the keys of a table in arbitrary order.
values (t)return all the values of the table in arbitrary order
sub (t, first, last)Extract a range from a table, like 'string.sub'.
+

Merging

+ + + + + + + + + + + + + +
merge (t1, t2, dup)combine two tables, either as union or intersection.
difference (s1, s2, symm)a new table which is the difference of two tables.
zip (...)return a table where each element is a table of the ith values of an arbitrary + number of tables.
+ +
+
+ + +

Functions

+ +
+
+ + size (t) +
+
+ total number of elements in this table. + Note that this is distinct from #t, which is the number + of values in the array part; this value will always + be greater or equal. The difference gives the size of + the hash part, for practical purposes. Works for any + object with a __pairs metamethod. + + +

Parameters:

+
    +
  • t + tab + a table +
    • +
+ +

Returns:

+
    + + the size +
+ + + + +
+
+ + index_by (tbl, idx) +
+
+ return a list of all values in a table indexed by another list. + + +

Parameters:

+
    +
  • tbl + tab + a table +
    • +
  • idx + array + an index table (a list of keys) +
    • +
+ +

Returns:

+
    + + a list-like table +
+ + + +

Usage:

+
    + 
  • index_by({10,20,30,40},{2,4}) == {20,40}
    • + 
  • index_by({one=1,two=2,three=3},{'one','three'}) == {1,3}
    • +
+ +
+
+ + transform (fun, t, ...) +
+
+ apply a function to all values of a table, in-place. + Any extra arguments are passed to the function. + + +

Parameters:

+
    +
  • fun + func + A function that takes at least one argument +
    • +
  • t + tab + a table +
    • +
  • ... + extra arguments passed to fun +
    • +
+ + + +

See also:

+ + + +
+
+ + range (start, finish[, step=1]) +
+
+ generate a table of all numbers in a range. + This is consistent with a numerical for loop. + + +

Parameters:

+
    +
  • start + int + number +
    • +
  • finish + int + number +
    • +
  • step + int + make this negative for start < finish + (default 1) +
    • +
+ + + + + +
+
+ + reduce (fun, t, memo) +
+
+ 'reduce' a list using a binary function. + + +

Parameters:

+
    +
  • fun + func + a function of two arguments +
    • +
  • t + array + a list-like table +
    • +
  • memo + array + optional initial memo value. Defaults to first value in table. +
    • +
+ +

Returns:

+
    + + the result of the function +
+ + + +

Usage:

+
    + 
    reduce('+',{1,2,3,4}) == 10
    +
+ +
+
+ + index_map (t) +
+
+ create an index map from a list-like table. The original values become keys, + and the associated values are the indices into the original list. + + +

Parameters:

+
    +
  • t + array + a list-like table +
    • +
+ +

Returns:

+
    + + a map-like table +
+ + + + +
+
+ + makeset (t) +
+
+ create a set from a list-like table. A set is a table where the original values + become keys, and the associated values are all true. + + +

Parameters:

+
    +
  • t + array + a list-like table +
    • +
+ +

Returns:

+
    + + a set (a map-like table) +
+ + + + +
+
+ + union (t1, t2) +
+
+ the union of two map-like tables. + If there are duplicate keys, the second table wins. + + +

Parameters:

+
    +
  • t1 + tab + a table +
    • +
  • t2 + tab + a table +
    • +
+ +

Returns:

+
    + + tab + + + +
+ + +

See also:

+ + + +
+
+ + intersection (t1, t2) +
+
+ the intersection of two map-like tables. + + +

Parameters:

+
    +
  • t1 + tab + a table +
    • +
  • t2 + tab + a table +
    • +
+ +

Returns:

+
    + + tab + + + +
+ + +

See also:

+ + + +
+
+ + count_map (t, cmp) +
+
+ A table where the key/values are the values and value counts of the table. + + +

Parameters:

+
    +
  • t + array + a list-like table +
    • +
  • cmp + func + a function that defines equality (otherwise uses ==) +
    • +
+ +

Returns:

+
    + + a map-like table +
+ + +

See also:

+ + + +
+
+ + set (t, val[, i1=1[, i2=#t]]) +
+
+ set an array range to a value. If it's a function we use the result + of applying it to the indices. + + +

Parameters:

+
    +
  • t + array + a list-like table +
    • +
  • val + a value +
    • +
  • i1 + int + start range + (default 1) +
    • +
  • i2 + int + end range + (default #t) +
    • +
+ + + + + +
+
+ + new (n, val) +
+
+ create a new array of specified size with initial value. + + +

Parameters:

+
    +
  • n + int + size +
    • +
  • val + initial value (can be nil, but don't expect # to work!) +
    • +
+ +

Returns:

+
    + + the table +
+ + + + +
+
+ + clear (t, istart) +
+
+ clear out the contents of a table. + + +

Parameters:

+
    +
  • t + array + a list +
    • +
  • istart + optional start position +
    • +
+ + + + + +
+
+ + removevalues (t, i1, i2) +
+
+ remove a range of values from a table. + End of range may be negative. + + +

Parameters:

+
    +
  • t + array + a list-like table +
    • +
  • i1 + int + start index +
    • +
  • i2 + int + end index +
    • +
+ +

Returns:

+
    + + the table +
+ + + + +
+
+ + readonly (t) +
+
+ modifies a table to be read only. + This only offers weak protection. Tables can still be modified with + table.insert and rawset.

+ +

NOTE: for Lua 5.1 length, pairs and ipairs will not work, since the + equivalent metamethods are only available in Lua 5.2 and newer. + + +

Parameters:

+
    +
  • t + tab + the table +
    • +
+ +

Returns:

+
    + + the table read only (a proxy). +
+ + + + +
+
+

Copying

+ +
+
+ + update (t1, t2) +
+
+ copy a table into another, in-place. + + +

Parameters:

+
    +
  • t1 + tab + destination table +
    • +
  • t2 + tab + source (actually any iterable object) +
    • +
+ +

Returns:

+
    + + first table +
+ + + + +
+
+ + copy (t) +
+
+ make a shallow copy of a table + + +

Parameters:

+
    +
  • t + tab + an iterable source +
    • +
+ +

Returns:

+
    + + new table +
+ + + + +
+
+ + deepcopy (t) +
+
+ make a deep copy of a table, recursively copying all the keys and fields. + This supports cycles in tables; cycles will be reproduced in the copy. + This will also set the copied table's metatable to that of the original. + + +

Parameters:

+
    +
  • t + tab + A table +
    • +
+ +

Returns:

+
    + + new table +
+ + + + +
+
+ + icopy (dest, src[, idest=1[, isrc=1[, nsrc=#src]]]) +
+
+ copy an array into another one, clearing dest after idest+nsrc, if necessary. + + +

Parameters:

+
    +
  • dest + array + a list-like table +
    • +
  • src + array + a list-like table +
    • +
  • idest + int + where to start copying values into destination + (default 1) +
    • +
  • isrc + int + where to start copying values from source + (default 1) +
    • +
  • nsrc + int + number of elements to copy from source + (default #src) +
    • +
+ + + + + +
+
+ + move (dest, src[, idest=1[, isrc=1[, nsrc=#src]]]) +
+
+ copy an array into another one. + + +

Parameters:

+
    +
  • dest + array + a list-like table +
    • +
  • src + array + a list-like table +
    • +
  • idest + int + where to start copying values into destination + (default 1) +
    • +
  • isrc + int + where to start copying values from source + (default 1) +
    • +
  • nsrc + int + number of elements to copy from source + (default #src) +
    • +
+ + + + + +
+
+ + insertvalues (t[, position], values) +
+
+ insert values into a table. + similar to table.insert but inserts values from given table values, + not the object itself, into table t at position pos. + + +

Parameters:

+
    +
  • t + array + the list +
    • +
  • position + int + (default is at end) + (optional) +
    • +
  • values + array + + + +
    • +
+ + + + + +
+
+

Comparing

+ +
+
+ + deepcompare (t1, t2[, ignore_mt[, eps]]) +
+
+ compare two values. + if they are tables, then compare their keys and fields recursively. + + +

Parameters:

+
    +
  • t1 + A value +
    • +
  • t2 + A value +
    • +
  • ignore_mt + bool + if true, ignore __eq metamethod (default false) + (optional) +
    • +
  • eps + number + if defined, then used for any number comparisons + (optional) +
    • +
+ +

Returns:

+
    + + true or false +
+ + + + +
+
+ + compare (t1, t2, cmp) +
+
+ compare two arrays using a predicate. + + +

Parameters:

+
    +
  • t1 + array + an array +
    • +
  • t2 + array + an array +
    • +
  • cmp + func + A comparison function; bool = cmp(t1_value, t2_value) +
    • +
+ +

Returns:

+
    + + true or false +
+ + + +

Usage:

+
    + 
    assert(tablex.compare({ 1, 2, 3 }, { 1, 2, 3 }, "=="))
+
+assert(tablex.compare(
+   {1,2,3, hello = "world"},  -- fields are not compared!
+   {1,2,3}, function(v1, v2) return v1 == v2 end)
    +
+ +
+
+ + compare_no_order (t1, t2, cmp) +
+
+ compare two list-like tables using an optional predicate, without regard for element order. + + +

Parameters:

+
    +
  • t1 + array + a list-like table +
    • +
  • t2 + array + a list-like table +
    • +
  • cmp + A comparison function (may be nil) +
    • +
+ + + + + +
+
+

Finding

+ +
+
+ + find (t, val, idx) +
+
+ return the index of a value in a list. + Like string.find, there is an optional index to start searching, + which can be negative. + + +

Parameters:

+
    +
  • t + array + A list-like table +
    • +
  • val + A value +
    • +
  • idx + int + index to start; -1 means last element,etc (default 1) +
    • +
+ +

Returns:

+
    + + index of value or nil if not found +
+ + + +

Usage:

+
    + 
  • find({10,20,30},20) == 2
    • + 
  • find({'a','b','a','c'},'a',2) == 3
    • +
+ +
+
+ + rfind (t, val, idx) +
+
+ return the index of a value in a list, searching from the end. + Like string.find, there is an optional index to start searching, + which can be negative. + + +

Parameters:

+
    +
  • t + array + A list-like table +
    • +
  • val + A value +
    • +
  • idx + index to start; -1 means last element,etc (default #t) +
    • +
+ +

Returns:

+
    + + index of value or nil if not found +
+ + + +

Usage:

+
    + 
    rfind({10,10,10},10) == 3
    +
+ +
+
+ + find_if (t, cmp, arg) +
+
+ return the index (or key) of a value in a table using a comparison function.

+ +

NOTE: the 2nd return value of this function, the value returned + by the comparison function, has a limitation that it cannot be false. + Because if it is, then it indicates the comparison failed, and the + function will continue the search. See examples. + + +

Parameters:

+
    +
  • t + tab + A table +
    • +
  • cmp + func + A comparison function +
    • +
  • arg + an optional second argument to the function +
    • +
+ +

Returns:

+
    +
  1. + index of value, or nil if not found
    2. +
  2. + value returned by comparison function (cannot be false!)
    3. +
+ + + +

Usage:

+
    + 
    -- using an operator
+local lst = { "Rudolph", true, false, 15 }
+local idx, cmp_result = tablex.rfind(lst, "==", "Rudolph")
+assert(idx == 1)
+assert(cmp_result == true)
+
+local idx, cmp_result = tablex.rfind(lst, "==", false)
+assert(idx == 3)
+assert(cmp_result == true)       -- looking up 'false' works!
+
+-- using a function returning the value looked up
+local cmp = function(v1, v2) return v1 == v2 and v2 end
+local idx, cmp_result = tablex.rfind(lst, cmp, "Rudolph")
+assert(idx == 1)
+assert(cmp_result == "Rudolph")  -- the value is returned
+
+-- NOTE: this fails, since 'false' cannot be returned!
+local idx, cmp_result = tablex.rfind(lst, cmp, false)
+assert(idx == nil)               -- looking up 'false' failed!
+assert(cmp_result == nil)
    +
+ +
+
+ + search (t, value[, exclude]) +
+
+ find a value in a table by recursive search. + + +

Parameters:

+
    +
  • t + tab + the table +
    • +
  • value + the value +
    • +
  • exclude + array + any tables to avoid searching + (optional) +
    • +
+ +

Returns:

+
    + + a fieldspec, e.g. 'a.b' or 'math.sin' +
+ + + +

Usage:

+
    + 
    search(_G,math.sin,{package.path}) == 'math.sin'
    +
+ +
+
+

MappingAndFiltering

+ +
+
+ + map (fun, t, ...) +
+
+ apply a function to all values of a table. + This returns a table of the results. + Any extra arguments are passed to the function. + + +

Parameters:

+
    +
  • fun + func + A function that takes at least one argument +
    • +
  • t + tab + A table +
    • +
  • ... + optional arguments +
    • +
+ + + + +

Usage:

+
    + 
    map(function(v) return v*v end, {10,20,30,fred=2}) is {100,400,900,fred=4}
    +
+ +
+
+ + imap (fun, t, ...) +
+
+ apply a function to all values of a list. + This returns a table of the results. + Any extra arguments are passed to the function. + + +

Parameters:

+
    +
  • fun + func + A function that takes at least one argument +
    • +
  • t + array + a table (applies to array part) +
    • +
  • ... + optional arguments +
    • +
+ +

Returns:

+
    + + a list-like table +
+ + + +

Usage:

+
    + 
    imap(function(v) return v*v end, {10,20,30,fred=2}) is {100,400,900}
    +
+ +
+
+ + map_named_method (name, t, ...) +
+
+ apply a named method to values from a table. + + +

Parameters:

+
    +
  • name + string + the method name +
    • +
  • t + array + a list-like table +
    • +
  • ... + any extra arguments to the method +
    • +
+ +

Returns:

+
    + + a List with the results of the method (1st result only) +
+ + + +

Usage:

+
    + 
    local Car = {}
+Car.__index = Car
+function Car.new(car)
+  return setmetatable(car or {}, Car)
+end
+Car.speed = 0
+function Car:faster(increase)
+  self.speed = self.speed + increase
+  return self.speed
+end
+
+local ferrari = Car.new{ name = "Ferrari" }
+local lamborghini = Car.new{ name = "Lamborghini", speed = 50 }
+local cars = { ferrari, lamborghini }
+
+assert(ferrari.speed == 0)
+assert(lamborghini.speed == 50)
+tablex.map_named_method("faster", cars, 10)
+assert(ferrari.speed == 10)
+assert(lamborghini.speed == 60)
    +
+ +
+
+ + map2 (fun, t1, t2, ...) +
+
+ apply a function to values from two tables. + + +

Parameters:

+
    +
  • fun + func + a function of at least two arguments +
    • +
  • t1 + tab + a table +
    • +
  • t2 + tab + a table +
    • +
  • ... + extra arguments +
    • +
+ +

Returns:

+
    + + a table +
+ + + +

Usage:

+
    + 
    map2('+',{1,2,3,m=4},{10,20,30,m=40}) is {11,22,23,m=44}
    +
+ +
+
+ + imap2 (fun, t1, t2, ...) +
+
+ apply a function to values from two arrays. + The result will be the length of the shortest array. + + +

Parameters:

+
    +
  • fun + func + a function of at least two arguments +
    • +
  • t1 + array + a list-like table +
    • +
  • t2 + array + a list-like table +
    • +
  • ... + extra arguments +
    • +
+ + + + +

Usage:

+
    + 
    imap2('+',{1,2,3,m=4},{10,20,30,m=40}) is {11,22,23}
    +
+ +
+
+ + mapn (fun, ..., fun) +
+
+ Apply a function to a number of tables. + A more general version of map + The result is a table containing the result of applying that function to the + ith value of each table. Length of output list is the minimum length of all the lists + + +

Parameters:

+
    +
  • fun + A function that takes as many arguments as there are tables +
    • +
  • ... + tab + n tables +
    • +
  • fun + A function that takes as many arguments as there are tables +
    • +
+ + + + +

Usage:

+
    + 
  • mapn(function(x,y,z) return x+y+z end, {1,2,3},{10,20,30},{100,200,300}) is {111,222,333}
    • + 
  • mapn(math.max, {1,20,300},{10,2,3},{100,200,100}) is    {100,200,300}
    • +
+ +
+
+ + pairmap (fun, t, ...) +
+
+ call the function with the key and value pairs from a table. + The function can return a value and a key (note the order!). If both + are not nil, then this pair is inserted into the result: if the key already exists, we convert the value for that + key into a table and append into it. If only value is not nil, then it is appended to the result. + + +

Parameters:

+
    +
  • fun + func + A function which will be passed each key and value as arguments, plus any extra arguments to pairmap. +
    • +
  • t + tab + A table +
    • +
  • ... + optional arguments +
    • +
+ + + + +

Usage:

+
    + 
  • pairmap(function(k,v) return v end,{fred=10,bonzo=20}) is {10,20} _or_ {20,10}
    • + 
  • pairmap(function(k,v) return {k,v},k end,{one=1,two=2}) is {one={'one',1},two={'two',2}}
    • +
+ +
+
+ + filter (t, pred, arg) +
+
+ filter an array's values using a predicate function + + +

Parameters:

+
    +
  • t + array + a list-like table +
    • +
  • pred + func + a boolean function +
    • +
  • arg + optional argument to be passed as second argument of the predicate +
    • +
+ + + + + +
+
+

Iterating

+ +
+
+ + foreach (t, fun, ...) +
+
+ apply a function to all elements of a table. + The arguments to the function will be the value, + the key and finally any extra arguments passed to this function. + Note that the Lua 5.0 function table.foreach passed the key first. + + +

Parameters:

+
    +
  • t + tab + a table +
    • +
  • fun + func + a function on the elements; function(value, key, ...) +
    • +
  • ... + extra arguments passed to fun +
    • +
+ + + +

See also:

+ + + +
+
+ + foreachi (t, fun, ...) +
+
+ apply a function to all elements of a list-like table in order. + The arguments to the function will be the value, + the index and finally any extra arguments passed to this function + + +

Parameters:

+
    +
  • t + array + a table +
    • +
  • fun + func + a function with at least one argument +
    • +
  • ... + optional arguments +
    • +
+ + + + + +
+
+ + sort (t, f) +
+
+ return an iterator to a table sorted by its keys + + +

Parameters:

+
    +
  • t + tab + the table +
    • +
  • f + func + an optional comparison function (f(x,y) is true if x < y) +
    • +
+ +

Returns:

+
    + + an iterator to traverse elements sorted by the keys +
+ + + +

Usage:

+
    + 
    for k,v in tablex.sort(t) do print(k,v) end
    +
+ +
+
+ + sortv (t, f) +
+
+ return an iterator to a table sorted by its values + + +

Parameters:

+
    +
  • t + tab + the table +
    • +
  • f + func + an optional comparison function (f(x,y) is true if x < y) +
    • +
+ +

Returns:

+
    + + an iterator to traverse elements sorted by the values +
+ + + +

Usage:

+
    + 
    for k,v in tablex.sortv(t) do print(k,v) end
    +
+ +
+
+

Extraction

+ +
+
+ + keys (t) +
+
+ return all the keys of a table in arbitrary order. + + +

Parameters:

+
    +
  • t + tab + A table +
    • +
+ + + + + +
+
+ + values (t) +
+
+ return all the values of the table in arbitrary order + + +

Parameters:

+
    +
  • t + tab + A table +
    • +
+ + + + + +
+
+ + sub (t, first, last) +
+
+ Extract a range from a table, like 'string.sub'. + If first or last are negative then they are relative to the end of the list + eg. sub(t,-2) gives last 2 entries in a list, and + sub(t,-4,-2) gives from -4th to -2nd + + +

Parameters:

+
    +
  • t + array + a list-like table +
    • +
  • first + int + An index +
    • +
  • last + int + An index +
    • +
+ +

Returns:

+
    + + a new List +
+ + + + +
+
+

Merging

+ +
+
+ + merge (t1, t2, dup) +
+
+ combine two tables, either as union or intersection. Corresponds to + set operations for sets () but more general. Not particularly + useful for list-like tables. + + +

Parameters:

+
    +
  • t1 + tab + a table +
    • +
  • t2 + tab + a table +
    • +
  • dup + bool + true for a union, false for an intersection. +
    • +
+ + + +

See also:

+ + +

Usage:

+
    + 
  • merge({alice=23,fred=34},{bob=25,fred=34}) is {fred=34}
    • + 
  • merge({alice=23,fred=34},{bob=25,fred=34},true) is {bob=25,fred=34,alice=23}
    • +
+ +
+
+ + difference (s1, s2, symm) +
+
+ a new table which is the difference of two tables. + With sets (where the values are all true) this is set difference and + symmetric difference depending on the third parameter. + + +

Parameters:

+
    +
  • s1 + tab + a map-like table or set +
    • +
  • s2 + tab + a map-like table or set +
    • +
  • symm + bool + symmetric difference (default false) +
    • +
+ +

Returns:

+
    + + a map-like table or set +
+ + + + +
+
+ + zip (...) +
+
+ return a table where each element is a table of the ith values of an arbitrary + number of tables. It is equivalent to a matrix transpose. + + +

Parameters:

+
    +
  • ... + array + arrays to be zipped +
    • +
+ + + + +

Usage:

+
    + 
    zip({10,20,30},{100,200,300}) is {{10,100},{20,200},{30,300}}
    +
+ +
+
+ + +
+
+
+generated by LDoc 1.4.6 +
+
+ + -- cgit v1.1-26-g67d0