Banri: Created page with "{{Documentation}} {{Helper module |name = Enum |fname1 = all( enum, [fn], [clone|false] ) |ftype1 = table, function/nil, boolean/nil |fuse1 = Loops..."

2021-03-24T01:55:04Z

Created page with "{{Documentation}} {{Helper module |name = Enum |fname1 = <nowiki>all( enum, [fn], [clone|false] )</nowiki> |ftype1 = table, function/nil, boolean/nil |fuse1 = Loops..."

New page

{{Documentation}}
{{Helper module
|name = Enum

|fname1 = <nowiki>all( enum, [fn], [clone|false] )</nowiki>
|ftype1 = table, function/nil, boolean/nil
|fuse1 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. If <code>fn</code> returns <code>true</code> for all elements then <code>all()</code> returns <code>true</code>, otherwise <code>false</code>. If no function is given <code>function( item ) return item end</code> is used.

|fname2 = <nowiki>any( enum, [fn], [clone|false] )</nowiki>
|ftype2 = table, function/nil, boolean/nil
|fuse2 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. If <code>fn</code> returns <code>true</code> for at least one element then <code>any()</code> returns <code>true</code>, otherwise <code>false</code>. If no function is given <code>function( item ) return item end</code> is used. If <code>clone</code> is <code>true</code> the input <code>enum</code> is deep copied using <code>mw.clone()</code> before use.

|fname3 = <nowiki>contains( enum, elem, [clone|false] )</nowiki>
|ftype3 = table, any, boolean/nil
|fuse3 = Returns <code>true</code> if <code>enum</code> contains <code>elem</code>, otherwise returns false.

|fname4 = <nowiki>each( enum, fn, [clone|false] )</nowiki>
|ftype4 = table, function, boolean/nil
|fuse4 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. This function returns nothing.

|fname5 = <nowiki>filter( enum, [fn], [clone|false] )</nowiki>
|ftype5 = table, function/nil, boolean/nil
|fuse5 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. If <code>fn</code> returns <code>true</code> the corresponding element is copied to a new table which is then returned. If no function is given <code>function( item ) return item end</code> is used.

|fname6 = <nowiki>find( enum, fn, [default|nil], [clone|false] )</nowiki>
|ftype6 = table, function, any, boolean/nil
|fuse6 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. The first element where <code>fn</code> returns <code>true</code> is returned. If no elements passes the test, <code>default</code> is returned.

|fname7 = <nowiki>find_index( enum, fn, [default|nil], [clone|false] )</nowiki>
|ftype7 = table, function, any, boolean/nil
|fuse7 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. The index of the first element where <code>fn</code> returns <code>true</code> is returned. If no elements passes the test, <code>default</code> is returned.

|fname8 = <nowiki>insert( enum1, enum2, [index|#enum1+1], [clone|false] )</nowiki>
|ftype8 = table, table, number, boolean/nil
|fuse8 = Returns a new table with <code>enum2</code> inserted into <code>enum1</code> at index <code>index</code>. If no index is given, <code>enum2</code> is appended to <code>enum1</code>.

|fname9 = <nowiki>intersect( enum1, enum2, [clone|false] )</nowiki>
|ftype9 = table, table, boolean/nil
|fuse9 = Returns a table containing elements which exist in both enums. The order of the elements is the same as the order they occure in <code>enum1</code>.

|fname10 = <nowiki>intersects( enum1, enum2, [clone|false] )</nowiki>
|ftype10 = table, table, boolean/nil
|fuse10 = Returns <code>true</code> if both sets have at least one element with equal values.

|fname11 = <nowiki>map( enum, fn, [clone|false] )</nowiki>
|ftype11 = table, function, boolean/nil
|fuse11 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. The return value of <code>fn</code> is appended to a new table. This new table is returned.

|fname12 = <nowiki>max_by( enum, fn, [clone|false] )</nowiki>
|ftype12 = table, function, boolean/nil
|fuse12 = Loops over the array part of <code>enum</code> and passes each element as the first argument to <code>fn</code>. <code>max_by()</code> returns two values, the first is the element where <code>fn</code> returned the largest value, the second is this largest value. The <code>></code> operator is used for the comparisons.

|fname13 = <nowiki>new( [enum|{}] )</nowiki>
|ftype13 = table
|fuse13 = Adds a metatable to <samp>enum</samp> which allows it use elementwise math operations on the table. Also makes it possible to use the colon : operator with all the other functions listed here that take a table as their first argument.
<syntaxhighlight lang='lua'>
local t = enum.new{1, 2, 3}
local t2 = enum{4, 5, 6} -- Alternative notation

mw.log( -t ) --> { -1, -2, -3 }
mw.log( t + 2 ) --> { 3, 4, 5 }
mw.log( t - 2 ) --> { -1, 0, 1 }
mw.log( t * 2 ) --> { 2, 4, 6 }
mw.log( t / 2 ) --> { 0.5, 1, 1.5 }
mw.log( t ^ 2 ) --> { 1, 4, 9 }

mw.log( t + t2 ) --> { 5, 7, 9 }
mw.log( t .. t2 ) --> { 1, 2, 3, 4, 5, 6 }
mw.log( t:sum() ) --> 6
mw.log( (t .. t2):reject{3, 4, 5} ) --> { 1, 2, 6 }
</syntaxhighlight>

|fname14 = <nowiki>newIncrementor( [start|1], [step|1] )</nowiki>
|ftype14 = number, number
|fuse14 = Returns a new incrementor function. Every time this incrementor function is called it returns a number <code>step</code> higher than the previous call. The current value can be obtained with <code>inc.n</code> or set <code>inc.n = number</code> where <code>inc</code> is an incrementor function. The step size can be changed with <code>inc.step = number</code>.

|fname15 = <nowiki>range( stop )</nowiki>;;
<nowiki>range( start, stop, [step|1] )</nowiki>
|ftype15 = number, number, number
|fuse15 = Returns a table containing a sequence of numbers from <code>start</code> to <code>stop</code> (both inclusive if ints, end-exclusive if floats) by <code>step</code>. <code>range(4)</code> produces <code>{1, 2, 3, 4}</code> (<code>start</code> defaults to <code>1</code>). <code>range(0, 4)</code> produces <code>{0, 1, 2, 3, 4}</code>. When <code>step</code> is given, it specifies the increment (or decrement).

|fname16 = <nowiki>reduce( enum, fn, [accumulator|enum[1]], [clone|false] )</nowiki>
|ftype16 = table, function, any, boolean/nil
|fuse16 = Loops over the array part of <code>enum</code> and passes each element as the first argument and <code>accumulator</code> as the second to <code>fn</code>. The return value of <code>fn</code> becomes the new <code>accumulator</code>. The final value of <code>accumulator</code> is returned. If no <code>accumulator</code> is given then the first element in <code>enum</code> is used.

|fname17 = <nowiki>reject( enum, [fn], [clone|false] )</nowiki>;;
<nowiki>reject( enum, [table], [clone|false] )</nowiki>
|ftype17 = table, function/table, boolean/nil
|fuse17 = The opposite of <code>filter()</code>. If the second argument is a table, every element in <code>enum</code> equal to any of the values in this table will be rejected.

|fname18 = <nowiki>rep( val, n, [clone|false] )</nowiki>
|ftype18 = any, number, boolean
|fuse18 = Returns a table with <samp>n</samp> copies of <samp>val</samp>.

|fname19 = <nowiki>scan( enum, fn, [accumulator|enum[1]], [clone|false] )</nowiki>
|ftype19 = table, function, any, boolean/nil
|fuse19 = Same as <code>reduce()</code> but each step is appended to a table. This table is then returned.

|fname20 = <nowiki>slice( enum, [start|1], [stop|#enum], [clone|false] )</nowiki>
|ftype20 = table, number/nil, number/nil, boolean/nil
|fuse20 = Returns a table containing all the elements of <code>enum</code> between the <code>start</code> and <code>stop</code> indices. The <code>start</code> and <code>stop</code> indices are inclusive.

|fname21 = <nowiki>split( enum, count, [clone|false] )</nowiki>
|ftype21 = table, number, boolean/nil
|fuse21 = Returns two tables where the first is equivalent to <code>slice( enum, 1, count )</code> and the second <code>slice( enum, count+1, #enum )</code>.

|fname22 = <nowiki>sum( enum, [clone|false] )</nowiki>
|ftype22 = table, boolean/nil
|fuse22 = Returns the sum of all array elements in <code>enum</code>.

|fname23 = <nowiki>take( enum, count, [clone|false] )</nowiki>
|ftype23 = table, number, boolean/nil
|fuse23 = Returns only the first table of <code>split( enum, count )</code>.

|fname24 = <nowiki>take_every( enum, n, [clone|false] )</nowiki>
|ftype24 = table, number, boolean/nil
|fuse24 = Returns a table containing every nth element of <code>enum</code>.

|fname25 = <nowiki>unique( enum, [fn], [clone|false] )</nowiki>
|ftype25 = table, function/nil, boolean/nil
|fuse25 = Returns a new table where all duplicate values in <code>enum</code> are removed. In case a duplicate is present, the element with the lowest index will be kept and every subsequent duplicate element is removed. <code>fn</code> can be used to create a custom id for every element so that the result is a table with elements which all create a unique id. If no function is given <code>function( item ) return item end</code> is used.

|fname26 = <nowiki>zip( enums, [clone|false] )</nowiki>
|ftype26 = table, boolean/nil
|fuse26 = Groups elements with the same indexes from different arrays together, i.e. <code><nowiki>zip{ {a1, a2, a3}, {b1, b2, b3}, {c1, c2} } -> {{a1, b1, c1}, {a2, b2, c2}, {a3, b3}}</nowiki></code>

|example =
<syntaxhighlight lang='lua'>
local enum = require( 'Module:Enum' )

local seqOne = {1, 2, 3, 4, 10}
local seqTwo = {'a', 'b', 'b', 1}
local seqThree = {}
local var, var2

enum.any( seqOne, function( item ) return item == 3 end ) --> true
enum.all( seqTwo, function( item ) return type( item ) == 'string' end ) --> false
enum.each( seqOne, function( item ) table.insert( seqThree, item * 2 ) end ) --> seqThree = {2, 4, 6, 8, 20}
seqThree = enum.map( seqOne, function( item ) return item * 2 end ) --> seqThree = {2, 4, 6, 8, 20}
seqThree = enum.filter( seqTwo, function( item ) return type( item ) == 'string' end ) --> seqThree = {'a', 'b', 'b'}
seqThree = enum.reject( seqTwo, function( item ) return type( item ) == 'string' end ) --> seqThree = {1}
var = enum.find( seqOne, function( item ) return item > 5 end ) --> var = 10
var = enum.find_index( seqTwo, function( item ) return type( item ) ~= 'string' end ) --> var = 4
var, var2 = enum.max_by( seqOne, function( item ) return (item % 10) * item end ) --> var = 4, var2 = 16
var = enum.reduce( seqOne, function( item, acc ) return acc + item*item end, 5 ) --> var = 135
var = enum.range( 10, 1, -3 ) --> var = {10, 7, 4, 1}
seqThree = enum.scan( seqOne, function( item, acc ) return acc + item*item end, 5 ) --> seqThree = {6, 10, 19, 35, 135}
seqThree = enum.slice( seqOne, 2, 4 ) --> seqThree = {2, 3, 4}
var, var2 = enum.split( seqOne, 2 ) --> var = {1, 2}, var2 = {3, 4, 10}
var = enum.sum( seqOne ) --> var = 20
seqThree = enum.take( seqOne, 2 ) --> seqThree = {1, 2}
seqThree = enum.take_every( seqOne, 2 ) --> seqThree = {1, 3, 10}
seqThree = enum.unique( seqTwo ) --> seqThree = {'a', 'b', 1}
seqThree = enum.zip( {seqOne, seqTwo, {20, 30}} ) --> seqThree = {{1, 'a', 20}, {2, 'b', 30}, {3, 'b'}, {4, 1}, {10}}
seqThree = enum.insert( seqOne, seqTwo, 3 ) --> seqThree = {1, 2, 'a', 'b', 'b', 1, 3, 4, 10}
seqThree = enum.intersect( seqOne, seqTwo ) --> seqThree = {1}
var = enum.intersects( seqOne, seqTwo ) --> var = true
cond = enum.contains({ 1, 2, 3}, 3) --> cond = true

inc = enum.newIncrementor( 10, 5 )
print( inc() ) --> 10
print( inc() ) --> 15

-- Reason to use clone:
seqOne = {{1}, {2}}
seqTwo = enum.slice( seqOne, 2, 2 ) --> seqTwo = {{2}}
seqTwo[1][1] = 5
mw.log( seqOne[2][1] ) --> 5, The value in seqOne also got changed

seqOne = {{1}, {2}}
seqThree = enum.slice( seqOne, 2, 2, true ) --> seqThree = {{2}}
seqThree[1][1] = 5
mw.log( seqOne[2][1] ) --> 2, The value in seqOne is unchanged
</syntaxhighlight>
}}

Module:Enum/doc - Revision history

Banri: Created page with "{{Documentation}} {{Helper module |name = Enum |fname1 = all( enum, [fn], [clone|false] ) |ftype1 = table, function/nil, boolean/nil |fuse1 = Loops..."