5Built-in Class

func(v0, v1, v2):[attr1,attr2] = {
    printf('arg#%d %s\n', 0.., __arg__.values)
    printf('attr1:%s attr2:%s\n', __arg__.isset(`attr1), __arg__.isset(`attr2))
}

The function instance that has created the argument.

A list of argument values.

Signals finalizing status to trailers after the current function.

Returns true if the function is called with an attribute that matches the specified symbol.

Cancels evaluation of following trailers.

Example:

f(flag:boolean) = {
    !flag && __arg__.quit_trailer() 
}

f(true) println('printed')
f(false) println('not printed')

Return an array with its row and column being tranposed.

Returns the size of each element in bytes.

Returns the type name of the elements as a symbol including: `boolean, `int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64, `half, `float, `double and `complex.

Returns the major-mode in symbols `row or `column.

Returns the id of memory.

Returns the number of dimensions.

Returns the pointer through which you can inspect and modify the content of the array as a binary data.

Returns a list of sizes of each dimension.

Returns the total number of elements.

Creates an array instance that contains double type of elements from a list or an iterator specified as an argument src or from elements described in the block. The followings are examples to create an array instance:

array([[0, 1, 2], [3, 4, 5]])
array {{0, 1, 2}, {3, 4, 5}}

Specifying the argument elemtype would create an array of element type other than double. The following examples create an array instance of int32 elements:

array([[0, 1, 2], [3, 4, 5]], elemtype => `int32)
array(elemtype => `int32) {{0, 1, 2}, {3, 4, 5}}

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Functions named array@T where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@int32 ([[0, 1, 2], [3, 4, 5]])
array@int32 {{0, 1, 2}, {3, 4, 5}}

Creates an array of double type of elements that represents an identity matrix with specified size n.

Example:

x = array.identity(3)
// x is array@double {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of int32 elements:

array.identity(3, elemtype => `int32)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.identity where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@int32.identity(3)

Creates a one-dimentional array with double type of element that contains a sequence of numbers according to the beginning, ending numbers and the number of samples between them.

In default, it creates a sequence with a range of [begin, end] meaning that the sequence contains the beginning and ending numbers. Following attributes would control the range:

• :open .. Numbers in range of (begin, end) that doesn't contain either begin or end.
• :open_l .. Numbers in range of (begin, end] that doesn't contain begin.
• :open_r .. Numbers in range of [begin, end) that doesn't contain end.

Example:

x = array.interval(0, 3, 7)
// x is array@double {0, 0.5, 1, 1.5, 2, 2.5, 3}

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.interval(0, 3, 7, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.interval where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@float.interval(0, 3, 7)

Creates an array of double type of elements, which are initialized with one. The argument dims specifies the dimension of the created array.

Example:

x = array.ones([3, 4])
// x is array@double {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}}

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of int32 elements:

array.ones([3, 4], elemtype => `int32)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.ones where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@int32.ones([3, 4])

Creates an array of double type of elements which are initialized with random numbers. The argument dims specifies the dimension of the created array. When the argument range is specified, the generated elements are all integer numbers that are ranged within [0, range). Otherwise, the generated elements are real numbers ranged within [0, 1).

Example:

x = array.rands([3, 4], 10)
// x is like array@double {{6, 7, 6, 9}, {3, 3, 6, 0}, {7, 9, 5, 5}}

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of int32 elements:

array.rands([3, 4], 10, elemtype => `int32)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.rands where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@int32.rands([3, 4], 10)

Creates an array of double type of elements which are initialized with normal distribution random numbers. The argument dims specifies the dimension of the created array. The arguments mu and sigma supply parameters for normal distribution where mu specifies the mean value and sigma the standard deviation. In default, the mu is zero and sigma one.

Example:

x = array.rands@normal([3, 4], 1, 3)

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.rands@normal([3, 4], 1, 3, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.rands@normal where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@int32.rands@normal([3, 4], 1, 3)

Creates an array of double type of elements that are initialized with a sequence of integer numbers.

This function can generate three types of sequence like below:

• array.range(num) .. between 0 and (num - 1).
• array.range(num, num_end) .. between num and (num_end - 1).
• array.range(num, num_end, step) .. between num and (num_end - 1) incremented by step.

Example:

x = array.range(5)
// x is array@double {0, 1, 2, 3, 4}
x = array.range(2, 5)
// x is array@double {2, 3, 4}
x = array.range(2, 10, 2)
// x is array@double {2, 4, 6, 8}

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of int32 elements:

array.range(5, elemtype => `int32)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.range where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@int32.range(5)

Creates an array of double type of elements representing a matrix to rotate a 2-D coord.

The rotation angle is specified in radian value. If the attribute :deg is specified, the angle is specified in degree value.

If one or both of xtrans and ytrans are specified, it would create an array that works as translation as well as rotation.

Example:

x = array.rotation(math.pi / 6)
// x is a matrix to rotate by pi/6.
x = array.rotation(30):deg
// x is a matrix to rotate by 30 degree, which is pi/6 in radian.
x = array.rotation(math.pi / 6, 3, 5)
// x is a matrix to rotate by pi/6 and translate by [3, 5].

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.rotation(math.pi / 6, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.rotation where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@float.rotation(math.pi / 6)

Creates an array of double type of elements representing a matrix to rotate a 3-D coord around x-axis.

The rotation angle is specified in radian value. If the attribute :deg is specified, the angle is specified in degree value.

If one or more of xtrans, ytrans and ztrans are specified, it would create an array that works as translation as well as rotation.

Example:

x = array.rotation@x(math.pi / 6)
// x is a matrix to rotate by pi/6.
x = array.rotation@x(30):deg
// x is a matrix to rotate by 30 degree, which is pi/6 in radian.
x = array.rotation@x(math.pi / 6, 3, -2, 5)
// x is a matrix to rotate by pi/6 and translate by [3, -2, 5].

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.rotation@x(math.pi / 6, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.rotation@x where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@float.rotation@x(math.pi / 6)

Creates an array of double type of elements representing a matrix to rotate a 3-D coord around y-axis.

The rotation angle is specified in radian value. If the attribute :deg is specified, the angle is specified in degree value.

If one or more of xtrans, ytrans and ztrans are specified, it would create an array that works as translation as well as rotation.

Example:

x = array.rotation@y(math.pi / 6)
// x is a matrix to rotate by pi/6.
x = array.rotation@y(30):deg
// x is a matrix to rotate by 30 degree, which is pi/6 in radian.
x = array.rotation@y(math.pi / 6, 3, -2, 5)
// x is a matrix to rotate by pi/6 and translate by [3, -2, 5].

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.rotation@y(math.pi / 6, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.rotation@y where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@float.rotation@y(math.pi / 6)

Creates an array of double type of elements representing a matrix to rotate a 3-D coord around z-axis.

The rotation angle is specified in radian value. If the attribute :deg is specified, the angle is specified in degree value.

If one or more of xtrans, ytrans and ztrans are specified, it would create an array that works as translation as well as rotation.

Example:

x = array.rotation@z(math.pi / 6)
// x is a matrix to rotate by pi/6.
x = array.rotation@z(30):deg
// x is a matrix to rotate by 30 degree, which is pi/6 in radian.
x = array.rotation@z(math.pi / 6, 3, -2, 5)
// x is a matrix to rotate by pi/6 and translate by [3, -2, 5].

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.rotation@z(math.pi / 6, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.rotation@z where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@float.rotation@z(math.pi / 6)

Creates an array of double type of elements representing a matrix to scale a coord.

It creates a matrix that works on a 2-D coord if xscale and yscale are specified while it creates a matrix on a 3-D coord if xscale, yscale and zscale are specified.

Example:

x = array.scaling(3, 4)
// x is a matrix to scale a 2-D coord by [3, 4].
x = array.scaling(3, 4, -2)
// x is a matrix to scale a 3-D coord by [3, 4, -2].

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.scaling(3, 4, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.scaling where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@float.scaling(3, 4

Creates an array of double type of elements representing a matrix to translate a coord.

It creates a matrix that works on a 2-D coord if xtrans and ytrans are specified while it creates a matrix on a 3-D coord if xtrans, ytrans and ztrans are specified.

Example:

x = array.translation(3, 4)
// x is a matrix to translate a 2-D coord by [3, 4].
x = array.translation(3, 4, -2)
// x is a matrix to translate a 3-D coord by [3, 4, -2].

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of float elements:

array.translation(3, 4, elemtype => `float)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.translation where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@float.translation(3, 4

Creates an array of double type of elements, which are initialized with zero. The argument dims specifies the dimension of the created array.

Example:

x = array.zeros([3, 4])
// x is array@double {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Specifying the argument elemtype would create an array of element type other than double. The followings examples create an array instance of int32 elements:

array.zeros([3, 4], elemtype => `int32)

Available element types are:

`int8, `uint8, `int16, `uint16, `int32, `uint32, `int64, `uint64
`half, `float, `double, `complex

Methods named array@T.zeros where T gets an element type name are also provided to create an array instance of a specific type more easily. Using these functions could simplify the code above like this:

array@int32.zeros([3, 4])

Returns index of a maximum number of elements in the target array.

Returns index of a minimum number of elements in the target array.

Calculates a dot product between two arrays that have one or two dimensions.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Prints out a binary dump of the array's content.

Creates an iterator that iterates each element in the array.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

The block parameter is |elem:number, idx:number| where elem is the element value.

Cast value type of contained elements.

Available symbols for elemtype are as follows:

• `boolean
• `int8
• `uint8
• `int16
• `uint16
• `int32
• `uint32
• `int64
• `uint64
• `half
• `float
• `double
• `complex

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Fills array with a specified value.

Returns an array instance as a result that has flattened elements in the target array.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Returns an array instance as a result that has extracted n elements from the beginning of the target array.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Returns an array instance as a result that has elements of inverted matrix of the target array. If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Returns true if the target array instance has the same elements with the specified array.

Returns true if the target array consists square matrices.

Finds a maximum number of elements in the target array.

Calculates an mean value of elements in the array.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Finds a minimum number of elements in the target array.

Returns an array instance as a result that has extracted elements of the target array after skipping its first n elements.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Pastes elements of src into the target array instance.

The argument offset specifies the posision where elements are pasted in

Returns an array instance as a result that has reshaped the target array according to a list of dimension size specified by dims.

Below are examples:

x = array(1..24)
a = x.reshape([6, 4])    // a is an array of 6x4.
b = x.reshape([2, 3, 4]) // b is an array of 2x3x4.

A value of nil in the list of dimension means it would be calculated from the whole size and other dimension sizes. Only one nil is allowed to exist.

x = array(1..24)
b = x.reshape([2, nil, 4]) // b is an array of 2x3x4.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Returns an array instance as a result that has rounded off elements less than threshold to zero in the target array. The default value for threshold is 1.0e-6 when omitted.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Calculates a standard deviation value of elements in the target array.

In default, it calculates an unbiased estimation of standard deviation in which the summation of squared deviations is divided by (n - 1). Specifying :p attributes will calculate a population variance that divides that summation by n.

Calculates a summation value of elements in the target array.

Returns an array instance as a result that has extracted n elements from the bottom of the target array.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Creates an array instance that transposes axes of the original array according to the specified argument axes.

If the argument is not specified, two axes at the lowest rank, which correspond to row and column for a matrix, would be transposed.

If block is specified, it would be evaluated with a block parameter |array:array|, where array is the created instance. In this case, the block's result would become the function's returned value.

Calculates a variation value of elements in the target array.

In default, it calculates an unbiased estimation of standard deviation in which the summation of squared deviations is divided by (n - 1). Specifying :p attributes will calculate a population variance that divides that summation by n.

b'AB\xfe\x03CD'

Returns a pointer instance that accesses the binary. This result is equivalent to that of calling the method binary#pointer()

Returns the binary size in bytes.

Indicates if the content of the binary object is writable.

Creates a binary instance after combining string or binary specified by the arguments buff. If no argument is specified for buff, an empty binary instance would be created.

If block is specified, it would be evaluated with a block parameter |bin:binary|, where bin is the created instance. In this case, the block's result would become the function's returned value.

Creates a binary instance that has the specified size of buffer. If the argument data, which should have a number between 0 and 255, is specified, the buffer would be initialized with the value.

If block is specified, it would be evaluated with a block parameter |bin:binary|, where bin is the created instance. In this case, the block's result would become the function's returned value.

Prints a hexadecimal dump from the content of the binary to the standard output. If the argument stream is specified, the result would be output to the stream.

In default, hexadecimal digit are printed with lower-case characters. Specifying an attribute :upper would output them with upper-case characters instead.

Example:

>>> b'A quick brown fox jumps over the lazy dog.'.dump():upper
41 20 71 75 69 63 6B 20 62 72 6F 77 6E 20 66 6F  A quick brown fo
78 20 6A 75 6D 70 73 20 6F 76 65 72 20 74 68 65  x jumps over the
20 6C 61 7A 79 20 64 6F 67 2E                     lazy dog.

Returns a pointer instance that has an initial offset specified by the argument offset. If the argument is omitted, it would return a pointer instance that points to the top of the binary.

If block is specified, it would be evaluated with a block parameter |p:pointer|, where p is the created instance. In this case, the block's result would become the function's returned value.

Creates a stream instance with which you can read data from the binary by stream#read() method. If block is specified, it would be evaluated with a block parameter |s:stream|, where s is the created instance. In this case, the block's result would become the function's returned value.

Creates a stream instance with which you can append data to the binary by stream#write() method. If block is specified, it would be evaluated with a block parameter |s:stream|, where s is the created instance. In this case, the block's result would become the function's returned value.

Creates a codec instance of the specified encoding name. You can call codecs.dir() to get a list of available encoding names.

If block is specified, it would be evaluated with a block parameter |codec:codec|, where codec is the created instance. In this case, the block's result would become the function's returned value.

The codec's encoder has a feature to add a CR code (0x0d) before a LF code (0x0a) so that the lines are joined with CR-LF codes in the encoded result. This method enables or disables the feature.

• To enable it, call the method with the argument flag set to true or without any argument.
• To disable it, call the method with the argument flag set to false.

Decodes a binary buff and returns the decoded result as string.

The codec's decoder has a feature to delete a CR code (0x0d) before a LF code (0x0a) so that the lines are joined with LF code in the decoded result. This method enables or disables the feature.

• To enable it, call the method with the argument flag set to true or without any argument.
• To disable it, call the method with the argument flag set to false.

Encodes a string str and returns the encoded result as binary.

Value of the alpha element.

Value of the blue element.

Value of the green element.

Value of the red element.

Creates a color instance.

If block is specified, it would be evaluated with a block parameter |c:color|, where c is the created instance. In this case, the block's result would become the function's returned value.

There are two forms to call this function as below:

• color(name:string, a?:number) .. Creates an instance from color name and an optional alpha element. Predefined variable color.names is a list that contains available color names. A string in a format of '#rrggbb' that is used in HTML documents is also acceptable as a color name.
• color(r:number, g?:number, b?:number, a?:number) .. Creates an instance from RGB elements and an optional alpha element.

Calculates a gray scale from RGB elements in the color instance.

This is computed by a formula: gray = 0.299 * red + 0.587 * blue + 0.114 * blue.

Returns a color string in a format of '#rrggbb' that is used in HTML documents.

Returns a list of RGB elements in a form [r, g, b].

Specifying :alpha attribute would add the alpha element to the list.

Creates a complex instance with a real part real and an imaginary part imag.

If the argument imag is omitted, the imaginary part would be set to zero.

If block is specified, it would be evaluated with a block parameter |n:complex|, where n is the created instance. In this case, the block's result would become the function's returned value.

Creates a complex instance with an absolute number abs and an angle arg in polar coords.

The argument arg is specified in a unit of radian. You can give it a degree value by calling the function with :deg attribute.

If block is specified, it would be evaluated with a block parameter |n:complex|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns a complex number with real and imaginary parts being rounded off.

The argument threshold specifies the threshold value for the round-off.

If block is specified, it would be evaluated with a block parameter |n:complex|, where n is the created instance. In this case, the block's result would become the function's returned value.

Day value betwen 1 and 31.

Hour value between 0 and 23.

Minute value between 0 and 59.

Month value between 1 and 12.

Second value between 0 and 59.

Unixtime, a time in second since January 1st of 1970.

Milli second value between 0 and 999999.

Week day value between 0 and 6.

Day in a year between 1 and 366.

Year value between 1 and 9999.

Creates an instance of datetime class based on the specified arguments.

Explanations of the arguments are shown below:

• year .. Christian year.
• month .. Month starting from 1. Numbers from 1 to 12 correspond to January to December.
• day .. Day in a month starting from 1.
• hour .. Hour in a day between 0 and 23.
• min .. Minute in an hour between 0 and 59.
• sec .. Second in a minute between 0 and 59.
• usec .. Millisecond in a second between 0 and 999.
• minsoff .. Timezone offset in minutes.

In default, the instance has a timezone offset based on the current system settings.

If block is specified, it would be evaluated with a block parameter |dt:datetime|, where dt is the created instance. In this case, the block's result would become the function's returned value.

Eliminates timezone offset information from the instance.

Returns a string of the datetime properties based on the specified format. For the argument format, you can specify either a string of user-specific format or a symbol of predefined style.

A string of user-specific format contains following specifiers:

• %d .. day of month
• %H .. hour in 24-hour format
• %I .. hour in 12-hour format
• %m .. month
• %M .. minute
• %S .. second
• %w .. week number starting from 0 for Sunday.
• %y .. lower two digits of year
• %Y .. four digits of year

Below are the symbols of predefined styles:

• `w3c .. W3C style. eg) '2015-01-01T12:34:56+09:00'
• `http .. a style used in HTTP protocol. eg) 'Thu, 01 Jan 2015 12:34:56 +0900'
• `asctime .. a style used by the C function asctime(). eg) 'Thu Jan 1 12:34:56 +0900 2015'

Returns true if the specified year is a leap one.

Returns a number of days that exists in the specified month.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Creates a datetime instance of the current time.

In default, the timezone offset is set to one in the system setting. Specifying :utc attribute would set the offset to 0.

If block is specified, it would be evaluated with a block parameter |dt:datetime|, where dt is the created instance. In this case, the block's result would become the function's returned value.

Parses a string that describs date and time information and returns the datetime instance.

It is capable of parsing the following style:

• RFC1123 style. eg) 'Sat, 06 Nov 2010 08:49:37 GMT'
• RFC1036 style. eg) 'Saturday, 06-Nov-10 08:49:37 GMT'
• C's asctime() style. eg) 'Sat Nov 6 08:49:37 2010', 'Sat Nov 6 08:49:37 +0000 2010'
• W3C style. eg) '2010-11-06T08:49:37Z'

If block is specified, it would be evaluated with a block parameter |dt:datetime|, where dt is the created instance. In this case, the block's result would become the function's returned value.

Sets timezone offset in minutes.

Creates a datetime instance from time information. The date inforomation is set as 1st of January in the Christian year of 0.

If block is specified, it would be evaluated with a block parameter |dt:datetime|, where dt is the created instance. In this case, the block's result would become the function's returned value.

Creates a datetime instance of today. All the time information are cleared to 0.

In default, the timezone offset is set to one in the system setting. Specifying :utc attribute would set the offset to 0.

If block is specified, it would be evaluated with a block parameter |dt:datetime|, where dt is the created instance. In this case, the block's result would become the function's returned value.

Calculates UTC time of the target datetime instance. An error occurs if the instance has no timezone offset

Returns a week number for the specified date, which starts from 0 for Sunday.

f(a, b, c, d) = {}
println(f.decls:*name)

An expr instance that represents a default value in the declaration if exists. This is nil when no default value is specified.

A string instance that represents the declaration's name.

A symbol instance that represents the declaration's name.

Return true if the declaration is defined as a type that is specified in the arguments.

The argument type has following formats:

• a single symbol.
• a sequence of symbols joined by a dot.

In the second format, a symbol on the left side indicates a container such as a module and a class.

Below is an example to check if the declaration is defined as number type.

decl.istype(`number)

Below is an example to check if the declaration is defined as re.match type, which is a type named match defined in re module.

decl.istype(`re.match)

You can also specify a type by describing factors in separate arguments like below:

decl.istype(`re, `match)

dict {'first' => 1, 'second' => 2, 'third' => 3}
dict {{'first', 1}, {'second', 2}, {'third', 3}}
dict {'first', 1, 'second', 2, 'third', 3}

dict(['first' => 1, 'second' => 2, 'third' => 3])
dict([['first', 1], ['second', 2], ['third', 3]])
dict(['first', 1, 'second', 2, 'third', 3])

%{'first' => 1, 'second' => 2, 'third' => 3}
%{{'first', 1}, {'second', 2}, {'third', 3}}
%{'first', 1, 'second', 2, 'third', 3}

x = %{'first' => 1, 'second' => 2, 'third' => 3}

println(x['second']) // prints `2`
x['third'] = 33      // replaces `3` with `33`

Creates a dict instance.

It takes a list of key-value pairs in an argument as shown below:

d = dict([['apple', 100], ['grape', 200], ['banana', 80]])

Or, you can use a block to describe them like below:

d = dict {
    ['apple', 100], ['grape', 200], ['banana', 80]
}

You can specify values of number, string or symbol as dictionary keys.

You can also use the operator => to create a key-value pair like below:

d = dict(['apple' => 100, 'grape' => 200, 'banana' => 80])

Below is an example using a block:

d = dict {
    'apple' => 100, 'grape' => 200, 'banana' => 80
}

The symbol % is an alias of the function dict().

d = %{
    'apple' => 100, 'grape' => 200, 'banana' => 80
}

In default, if keys contain alphabet characters, different cases are distinguished. Appending the attribute :icase would ignore cases in them.

Adds multiple key-value pairs. It takes a list of key-value pairs in an argument or in a block that has the same format with one for the function dict().

If the specified key already exists in the dictionary, it would be overwritten. This behavior can be customized with the following attributes:

• :overwrite .. overwrite the existing one (default)
• :strict .. raises an error
• :timid .. keep the existing one

Clears all the key-value pairs in the dictionary.

Erases a key-value pair that mathces the provided key.

The key is either number, string or symbol.

Seeks a value that is associated with the specified key.

The method would return nil as its default value when the specified key doesn't exist in the dictionary. It would use different value if the argument default is specified.

Since the default value is also processed with implicit mapping, you have to apply object#nomap() method to it if you want to specify a list or an iterator as a default value.

When the attribute :raise is specified, an error occurs in the case of the key's absence.

Another measure to get a value associated with a key is to use an index operator. The following two codes have the same effect.

• v = d['foo']
• v = d.get('foo'):raise

Returns true if the specified key exists in the dictionary.

Returns an iterator of key-value pairs in the dictionary.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Returns an iterator of keys in the dictionary.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Returns the number of key-value pairs in the dictionary.

Adds a new key-value pair.

If the specified key already exists in the dictionary, it would be overwritten. This behavior can be customized with the following attributes:

• :overwrite .. overwrite the existing one (default)
• :strict .. raises an error
• :timid .. keep the existing one

Another measure to add a key-value pair is to use an index operator. The following two codes have the same effect.

• d['foo'] = 3
• d.put('foo', 3)

Returns an iterator of values in the dictionary.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates a directory instance from the specified path name.

Looks up a specified symbol in the environment and returns the associated value. In default, if the symbol is not defined in the environment, it will be searched in environments outside of the current one. Set escalate flag to false in order to disable such an escalation behaviour. Returns false when the symbol could not be found.

try {
    // any jobs
} catch {|e:error|
    // ...
}

The number of line where the expression that causes this error starts.

The number of line where the expression that causes this error ends.

A text that consists of a source name and a line number.

The name of the file that causes this error.

An error message. If an attribute :lineno is specified, it would contain a line number.

An iterator that generates expr instances that indicate stack trace.

Exists in "identifier" and "caller".

Exists in "identifier" and "caller".

Exists in "identifier" and "caller".

Exists in "caller".

Exists in "block".

Exists in "suffixed".

Exists in "compound".

Exists in "compound".

Exists in "unary".

Exists in "collector".

Exists in "binary".

Exists in "unaryop", "binaryop" and "assign".

Exists in "binary".

Exists in "suffixed".

Exists in "identifier".

Exists in "caller".

Exists in "value".

Parses a Gura script from the stream src and creates an expr instance.

If block is specified, it would be evaluated with a block parameter |expr:expr|, where expr is the created instance. In this case, the block's result would become the function's returned value.

Evaluates the expr instance.

If the argument env is specified, that environment is used for evaluation. If omitted, the current scope is used.

Parses a Gura script in the string script and creates an expr instance.

If block is specified, it will be evaluated with block parameter in a format of |expr:expr| where expr is the created instance.

Composes a script text from a content of expr.

Argument style specifies the text style output, which takes the following symbols:

• `crammed .. Puts all the text in one line and removes volatile spaces.
• `oneline .. Puts all the text in one line.
• `brief .. Omits content of blocks and long strings with "..".
• `fancy .. Prints in the most readable style. This is the default.

The argument indent specifies a string used for indentation. Its default is a sequence of four spaces.

Converts the expr into a function.

If the expr is a block that has a block parameter, that would be used as an argument list of the created function. Otherwise, the argument args declares the argument list.

It would be an error if args is specified and a block parameter exists as well.

Returns expr instance that has removed quote operator from the original expr.

Outputs a script that describes the expression to the specified stream.

Argument style specifies the text style output, which takes the following symbols:

• `crammed .. Puts all the text in one line and removes volatile spaces.
• `oneline .. Puts all the text in one line.
• `brief .. Omits content of blocks and long strings with "..".
• `fancy .. Prints in the most readable style. This is the default.

The argument indent specifies a string used for indentation. Its default is a sequence of four spaces.

Returns true if expr is an expression of unary.

Returns true if expr is an expression of unaryop.

Returns true if expr is an expression of quote.

Returns true if expr is an expression of binary.

Returns true if expr is an expression of binaryop.

Returns true if expr is an expression of assign.

Returns true if expr is an expression of member.

Returns true if expr is an expression of collector.

Returns true if expr is an expression of root.

Returns true if expr is an expression of block.

Returns true if expr is an expression of lister.

Returns true if expr is an expression of iterer.

Returns true if expr is an expression of compound.

Returns true if expr is an expression of indexer.

Returns true if expr is an expression of caller.

Returns true if expr is an expression of value.

Returns true if expr is an expression of identifier.

Returns true if expr is an expression of suffixed.

printf('name: %s, age: %d\n', name, age)

A = class {

    // any implementations

    __format_d__(fmt:format) = {
        // returns a string for %d specifier.
    }
}

a = A()
printf('%d', a) // a.__format_d__() is called

Returns an expected minimum width for the field.

For example, with '%3d', this method would return 3.

Returns a string containing a padding character, a space or '0'.

In default, a space is used for padding. For example, with '%3d', this method would return ' '.

When a character '0' appears after '%', that becomes the padding character. For example, with '%03d', this method would return '0'.

Returns a symbol that indicates an expected action when a positive number appears.

• `none .. No character ahead of the number.
• `space .. A space should be inserted.
• `plus .. A plus character should be inserted.

Returns an expected precision for the field.

For example, with '%.3d', this method would return 3.

Returns true if the field is expected to be aligned on left.

For example, with '%-3d', this method would return true.

Returns true if the specifier sequence includes '#' flag, which means some literal prefixes such as 0x are expected to be appended at the top.

For example, with '%#x', this method would return true.

Returns true if alphabet characters are expected to be shown in upper case.

Upper case characters are requested when a specifier such as '%X', '%E' and '%G' is specified.

f(a:number, b:number, c:number) = {
    (a + b + c) / 3
}

f = function(a:number, b:number, c:number) {
    (a + b + c) / 3
}

f = function {
    ($a + $b + $c) / 3
}

f = &{
    ($a + $b + $c) / 3
}

An iterator of declaration instances that provide information about argument declaration the function defines.

An expression of the function.

A string showing a declared format of the function.

A full name of the function that is prefixed by a name of the module or the class it belongs to.

A string instance that represents the function's name.

A symbol instance that represents the function's name.

>>> ~printf

Creates a function instance with an argument list of args and a procedure body provided by block.

Following two codes have the same effect with each other.

• f = function(a, b, c) { /* any job */ }
• f(a, b, c) = { /* any job */ }

Creates an iterator of declaration instances that provide information about argument declaration that the function instance func defines.

This class method returns the same information as the property function#decls.

Returns an expression of the function instance func.

It would return nil if the function is implemented with binary programs, not scripts.

This class method returns the same information as the property function#expr.

Returns a string showing a declared format of the function instance func.

This class method returns the same information as the property function#format.

Returns a full name of the function instance func, which is prefixed by a name of the module or the class the instance belongs to.

This class method returns the same information as the property function#fullname.

Returns a name of the function instance func in string type.

This class method returns the same information as the property function#name.

Returns a name of the function instance func in symbol type.

This class method returns the same information as the property function#symbol.

Returns a function instance that computes derivation of the target function, which is expected to contain only mathematical procedures. An error occurs if the target function has any elements that have nothing to do with mathematics.

In default, it differentiates the target function with respect to its first argument. Below is an example:

>>> f(x) = math.sin(x)
>>> g = f.mathdiff()    // g is a function to compute math.cos(x)

Specify a symbol to argument var when you want to differentiate with respect to another variable.

You can check the result of derivation by seeing property function#expr like below:

>>> g.expr
`math.cos(x)

Creates a gear@averagepool1d instance.

The size is a gear size.

The strides is a strides of sliding window. Default is one.

The padding is a padding style `valid or `same. Default is `same.

The channel_pos specifies where channel dimension is positioned and takes `first or `last. Default is `last.

Creates a gear@averagepool2d instance.

Creates a gear@averagepool3d instance.

Creates a gear@conv1d instance.

The array is an array instance that has one of the following shapes:

• [size] .. 1-dimension
• [size, channel_num] .. 2-dimensions and channel_pos is `last
• [channel_num, size] .. 2-dimensions and channel_pos is `first
• [filter_num, size] .. 2-dimensions and channel_pos is `none
• [filter_num, size, channel_num] .. 3-dimensions and channel_pos is `last
• [filter_num, channel_num, size] .. 3-dimensions and channel_pos is `first

where size is the size of the filter's kernel, channel_num is the number of channels and filter_num is the number of filters.

The strides is a strides for a sliding window. Default is one.

The padding is a padding style and takes `valid or `same. Default is `same. When valid is specified, there is no padding. When same is specified, zero values are padded so that the result array has the size of the division of the original size by strides.

The channel_pos is a channel position and takes `none, `first or `last. If not specified, `none` for an array without channel dimensionand `last for others are to be set.

Creates a gear@conv2d instance.

The given array instance shoud have one of the following shapes:

• [row_size, col_size] .. 2-dimensions
• [row_size, col_size, channel_num] .. 3-dimensions and channel_pos is `last
• [channel_num, row_size, col_size] .. 3-dimensions and channel_pos is `first
• [filter_num, row_size, col_size] .. 3-dimensions and channel_pos is `none
• [filter_num, row_size, col_size, channel_num] .. 4-dimensions and channel_pos is `last
• [filter_num, channel_num, row_size, col_size] .. 4-dimensions and channel_pos is `first

where row_size and col_size are the size of the filter's kernel, channel_num is the number of channels and filter_num is the number of filters.

The strides is a list of strides for a sliding window in row and column. Default is [1, 1].

The padding is a padding style and takes `valid or `same. Default is `same. When valid is specified, there is no padding. When same is specified, zero values are padded so that the result array has the size of the division of the original size by strides.

The channel_pos is a channel position and takes `none, `first or `last. If not specified, `none` for an array without channel dimensionand `last for others are to be set.

Creates a gear@conv3d instance.

The given array instance shoud have one of the following shapes:

• [plane_size, row_size, col_size] .. 3-dimensions
• [plane_size, row_size, col_size, channel_num] .. 4-dimensions and channel_pos is `last
• [channel_num, plane_size, row_size, col_size] .. 4-dimensions and channel_pos is `first
• [filter_num, plane_size, row_size, col_size] .. 4-dimensions and channel_pos is `none
• [filter_num, plane_size, row_size, col_size, channel_num] .. 5-dimensions and channel_pos is `last
• [filter_num, channel_num, plane_size, row_size, col_size] .. 5-dimensions and channel_pos is `first

where plane_size, row_size and col_size are the size of the filter's kernel, channel_num is the number of channels and filter_num is the number of filters.

The strides is a list of strides for a sliding window in plane, row and column. Default is [1, 1, 1].

The padding is a padding style and takes `valid or `same. Default is `same. When valid is specified, there is no padding. When same is specified, zero values are padded so that the result array has the size of the division of the original size by strides.

The channel_pos is a channel position and takes `none, `first or `last. If not specified, `none` for an array without channel dimensionand `last for others are to be set.

Creates a gear@maxpool1d instance.

The size is a gear size.

The strides is a strides of sliding window. Default is one.

The padding is a padding style `valid or `same. Default is `same.

The channel_pos specifies where channel dimension is positioned and takes `first or `last. Default is `last.

Creates a gear@maxpool2d instance.

Creates a gear@maxpool3d instance.

Creates a gear@relu instance.

Creates a gear@sigmoid instance.

Creates a gear@softmax instance.

Creates a gear@tanh instance.

The help text.

A name of the syntax format in which the help text is described such as 'markdown'.

A symbol of the natural language in which the help text is written. For example, `en for English and `ja for Japanese.

The title of the help.

Returns a help text for functions that return an iterator.

The argument lang is a symbol that specifies the language in which the text is written, e.g. `en for English and `ja for Japanese.

If block is specified, it would be evaluated with a block parameter |str:string|, where str is the created instance. In this case, the block's result would become the function's returned value.

Returns a help text that for functions that take a block .

The argument lang is a symbol that specifies the language in which the text is written, e.g. `en for English and `ja for Japanese.

In the text, variable names would be replaced by varname and type names by typename.

If block is specified, it would be evaluated with a block parameter |str:string|, where str is the created instance. In this case, the block's result would become the function's returned value.

Registers a presentation procedure with a name specified by the argument format.

The procedure is written in the block that takes block parameters: |help:help|.

Takes one of the following symbols indicating what elements are stored in the memory:

• `rgb .. red, green and blue
• `rgba .. red, green, blue and alpha

Image height.

A palette instance associated with this image. If there's no palette associated, this property returns nil.

Image width.

Returns an image instance with specified characteristics. There are three forms to call the function as below:

• image(format:symbol) .. Creates an image instance of the specified format without buffer allocated.
• image(format:symbol, width:number, height:number, color?:color) .. Allocates an image buffer with the specified size and fills it with the color.
• image(stream:stream, format?:symbol, imagetype?:string) .. Reads image data from the stream and allocates necessary buffer in which the read data is stored.

The argument format specifies what elements are stored in the memory and takes one of the following symbols:

• `rgb .. red, green and blue
• `rgba .. red, green, blue and alpha

In the third form, the format of the image data is determined by the byte sequence of the stream data and its file name.

You can also explicitly specify the image data format by the argument imagetype.

Allocates a specified size of buffer in the image instance that is supposed to has no buffer allocated.

The allocated buffer will be filled with color. If omitted, it will be filled with zero value.

An error occurs in following cases:

• It fails to allocate necessary buffer.
• The image instance already has allocated buffer.

Returns a new image that blurs the original image with the given parameters.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Fills the buffer in the image instance with zero value.

This has the same effect with calling image#fill() with color.zero.

This method returns the reference to the target instance itself.

Returns a new image instance of the extracted area of the source image.

The extracted area is specified by the following arguments:

• x .. The left position.
• y .. The top position.
• width .. The width. If it's omitted or specified with nil, the whole area on the right of x will be extracted.
• height .. The height. If it's omitted or specified with nil, the whole area on the bottom of y will be extracted.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Deletes a palette instance that belongs to the image.

This method returns the reference to the target instance itself.

Extracts the element values within the specified area of the image, and store them into a list. The argument x and y specifies the left-top position, and width, and height does the size of the area.

The argument element takes the following symbol that specifies which element should be extracted:

• `r .. red
• `g .. green
• `b .. blue
• `a .. alpha

The argument dst specifies the variable into which the extracted data is stored, which must be a list that has enough space to store the data.

This method returns the reference to the target instance itself.

Fills the whole image with the specified color.

This method returns the reference to the target instance itself.

Fills the specified area with the specified color. The argument x and y specifies the left-top position, and width, and height does the size of the area.

This method returns the reference to the target instance itself.

Returns a new image instance that flips the source image horizontally or vertically. You can specify the following symbol to the orient argument.

• `horz .. flips horizontally.
• `vert .. flips vertically.
• `both .. flips both horizontally and vertically. This has the same effect with rotating the image 180 degrees.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Returns a color of a pixel data at the specified position.

If block is specified, it would be evaluated with a block parameter |c:color|, where c is the created instance. In this case, the block's result would become the function's returned value.

Returns a new image instance that converts the source image into gray scale.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Returns a new image that converts color levels according to the given table.

Each of the arguments map@r, map@g and map@b is an instance of array@uchar containing 256 numbers that range between 0 and 255 and corresponds to elements red, green and blue respectively. An element value in the source image becomes an index of the list and the indexed value will be stored as a converted element value.

If you want to apply a mapping table to all the elements, call the method with a single argument like image#mapcolorlevel(map).

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Pastes the source image src onto the target image instance at the specified position.

The argument width, height, xoffset and yoffset specify the source image's area to be pasted. If they're omitted, the whole image will be pasted.

The argument a specifies the alpha value that is put on the target image.

This method returns the reference to the target instance itself.

Puts a color on the specified position.

This method returns the reference to the target instance itself.

Returns the image size as a list [width, height].

Reads image data from a stream.

The format of the image data is determined by the byte sequence of the stream data and its file name.

You can also explicitly specify the image data format by the argument imagetype.

This method returns the reference to the target instance itself.

Creates an image that reduces colors in the original image with a set of colors in the given palette. The specified palette would be associated with the created image.

If no argument is specified, the associated palette would be used. In this case, an error occurs if there's no palette associated.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Replaces pixels that have a color matching colorOrg with the color.

The argument tolerance specifies an acceptable distance for the matching. If omitted, only an exact match is acceptable.

This method returns the reference to the target instance itself.

Resizes the image to the size specified by width and height and returns the result.

• When both width and height are specified, the image would be resized to the size.
• When width is specified and height is omitted or nil, the resized height would be calculated from the width so that they keep the same ratio as the original.
• When width is nil and height is specified, the resized width would be calculated from the height so that they keep the same ratio as the original.

The following attributes are acceptable:

• :box .. When only width is specified, the same value is set to height.
• :ratio .. Treats values of width and height as magnifying ration instead of pixel size.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Creates an image that rotates the original image by the specified angle.

The argument angle specifies the rotation angle in degree unit, and positive numbers for counterclockwise direction and negative for clockwise direction.

The created instance has a size that exactly fits the rotated image. The argument background specifies the color of pixels to fill the empty area that appears after rotation. If omitted, the color that has all elements set to zero is used for filling.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Returns an iterator that scans pixels in the image.

The arguments x, y, width and height specify the image area to scan. The argument scandir specifies the scan direction and takes one of the following symbol:

Symbol	Start Pos	Direction
`left_top_horz	left-top	horizontal
`left_top_vert	left-top	vertical
`left_bottom_horz	left-bottom	horizontal
`left_bottom_vert	left-bottom	vertical
`right_top_horz	right-top	horizontal
`right_top_vert	right-top	vertical
`right_bottom_horz	right-bottom	horizontal
`right_bottom_vert	right-bottom	vertical

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Replaces the alpha element of all the pixels in the image with the value specified by a.

If the argument color is specified, alpha element of pixels that match with that color would be replaced. The argument tolerance specifies the distance within which the color is determined as matched.

This method returns the reference to the target instance itself.

Resizes the image so that it fits within a rectangular area specified by width and height and returns the result.

If block is specified, it would be evaluated with a block parameter |img:image|, where img is the created instance. In this case, the block's result would become the function's returned value.

Writes image data to a stream.

The format of the image data is determined by the stream's file name.

You can also explicitly specify the image data format by the argument imagetype.

This method returns the reference to the target instance itself.

Creates an iterator that combines iterators given in the argument.

If an argument is not an iterator, that would be added as an element.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that returns each element with an interval time specified by the argument delay in seconds.

Marks the iterator as a finite one by clearing its infinite flag.

This method returns the target instance itself.

Marks the iterator as an infinite one by setting its infinite flag.

This method returns the target instance itself.

Returns true if the iterator is infinite one.

The trait of iterator's infinity is used to avoid an endless process by evaluating an infinite iterator. An attempt to evaluate an infinite iterator such as creation of a list from it would occur an error.

Returns a next element of the iterator. This operation updates the iterator's internal status.

Makes the iterator behave as a "repeater". This would allow the iterator be evaulated when it appears as an element of another "repeater" iterator.

Below is an example:

x = repeat(3):iter {
    ['apple', 'orange', 'grape'].each()
}
println(x)
// Just prints iterator instance three times
// since x can't evaluate the internal iterator.

x = repeat(3):iter {
    ['apple', 'orange', 'grape'].each().repeater()
}
println(x)
// Prints 'apple', 'orange' and  'grape' three times
// after evaluating the internal iterator.

[3, 1, 4, 1, 5, 9]
@{3, 1, 4, 1, 5, 9}

x = [`A, `B, `C, `D, `E, `F]

println(x[2]) // prints `C
x[4] = `e     // replaces `E with `e

Creates a new list from given values in its argument list. If a given value is a list or an iteartor, elements it contains are added to the created list.

Creates a new list from given values except for nil in its argument list. If a given value is a list or an iteartor, elements it contains are added to the created list.

Creates a new list that contains unique values from given iterators in its argument list.

In default, all the elements in each iterators are added to the created list. Specifying the following attributes would apply a filtering condition.

• :and .. Elements that exist in all the iterators are added.
• :or .. All the elements are added. This is the default behavior.
• :xor .. Elements that exist in only one iterator are added.

Creates a new list that contains unique values except for nil from given iterators in its argument list.

In default, all the elements in each iterators are added to the created list. Specifying the following attributes would apply a filtering condition.

• :and .. Elements that exist in all the iterators are added.
• :or .. All the elements are added. This is the default behavior.
• :xor .. Elements that exist in only one iterator are added.

Add specified items to the list.

Adds specified items to the list. If the item is a list or an iterator, each element in such an item is added to the list.

Clear the content of the list.

Creates an iterator that generates lists that contain elements picked up from the original list in a combination manner.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Erases elements at the specified indices.

Returns a first value in the list. An error occurs when the list is empty.

Returns a value stored at the specified index in the list. An error occurs when the index is out of range.

Insert specified items to the list from the selected index.

Return true if the list is empty.

Returns a last value in the list. An error occurs when the list is empty.

Creates an iterator that generates lists that contain elements picked up from the original list in a permutation manner.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Stores a value at the specified index in the list. An error occurs when the index is out of range.

Shifts the elements of the list. If the content of the list is [1, 2, 3, 4], it becomes [2, 3, 4] after calling this method. In default, no error occurs even when the list is empty. To raise an error for executing this method on an empty list, specify :raise attribute.

Shuffle the order of the list content based on random numbers.

Creates an iterator generating lists that bind given argument values. When the value is a list or an iterator, each item in it would be zipped.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that picks up elements that appear at positions after the criteria is evaluated to be true.

You can specify a function, a list or an iterator as the criteria.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that returns the specified number of elements in the source iterator. If the number is larger than the length of the source iterator, the lacking part is filled with value. If the argument value is omitted, nil is used for the filling.

Below is an example to specify a number less than the source length:

x = [`A, `B, `C, `D, `E, `F].align(3)
// x generates `A, `B, `C.

Below is an example to specify a number that exceeds the source length:

x = [`A, `B, `C, `D, `E, `F].align(8)
// x generates `A, `B, `C, `D, `E, `F, nil, nil.

Calculates a logical AND result of all the values in the iterable.

Returns a position index where the maximum value is found at first.

The following attributes modify the behavior:

• :last_index .. returns an index where the maximum value is found at last.
• :indices .. returns a list of all indices where the maximum value is found.

Calling of methods iterable#argmas() and iteraboe#max() have the same effect when attributes are specified as follows:

• iterable.argmax() and iterable.max():index
• iterable.argmax():last_index and iterable.max():last_index
• iterable.argmax():indices and iterable.max():indices

Returns a position index where the minimum value is found at first.

The following attributes modify the behavior:

• :last_index .. returns an index where the minimum value is found at last.
• :indices .. returns a list of all indices where the minimum value is found.

Calling of methods iterable#argmas() and iteraboe#max() have the same effect when attributes are specified as follows:

• iterable.argmax() and iterable.max():index
• iterable.argmax():last_index and iterable.max():last_index
• iterable.argmax():indices and iterable.max():indices

Creates an iterator that extracts elements in the iterable before criteria is evaluated as true. You can specify a function object, a list or an iterator as the criteria.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Returns true if the specified value appears in the iterable.

Returns a number of elements that matches the given criteria which is a single-argument function or a value.

When a function is applied, it counts the number of true after evaluating element value with the function. If a value is applied, it counts the number of elements that are equal to the value.

Creates an iterator that iterates elements in the source iterator cyclically.

The argument n specifies the number of elements the created iterator returns. If omitted, it would iterates elements infinitely.

Below is an example:

x = [`A, `B, `C, `D, `E].cycle()
// x generates `A, `B, `C, `D, `E, `A, `B, `C, `D, `E, `A, `B, ..

Creates an iterator that iterates each element in the list.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterable that filters values in the source iterable by a criteria.

A criteria can be an iterable or a function instance.

• When the criteria is an iterable, the created iterator would scan the source and the criteria iterable simultaneously and would return a value of the source when the corresponding criteria value is evaluated as true.
• When the criteria is a function instance, the created iterator would give it a value of the source as an argument and would return the value when the function has returned true.

Below is an example to use an iterable as its criteria:

x = [3, 1, 4, 1, 5, 9]
y = filter(x > 3)
// (x > 3) makes a list [false, false, true, false, true, true]
// y generates 4, 5, 9

Below is an example to use a function as its criteria:

x = [3, 1, 4, 1, 5, 9]
y = filter(&{$x > 3})
// y generates 4, 5, 9

Creates an iterator that searches items recursively if they are lists or iterators.

Specifying an attribute could customize searching order as below:

• :dfs .. Searches in depth-first order. This is the default behavior.
• :bfs .. Searches in breadth-first order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Below is an example:

x = [[`A, `B, `C], [`D, `E, [`F, `G, `H], `I, `J], `K, `L]

y = x.flattten():dfs
// y generates `A, `B, `C, `D, `E, `F, `G, `H, `I, `J, `K, `L

y = x.flatten():bfs
// y generates `K, `L, `A, `B, `C, `D, `E, `I, `J, `F, `G, `H

Creates an iterator that packs n elements of the source iterator into a list and returns it as its element.

The argument nstep specifies the shift amount to the next packing.If omitted, the next packing is shifted by n elements.

Specifying the attribute :iteritem returns an iterator as its element instead of a list

If the last packing doesn't satisfy n elements, its list would be shorter than n. When specifying the attribute :neat, such an immature list would be eliminated.

Following is an example to fold elements by 3:

x = [`A, `B, `C, `D, `E, `F, `G, `H].fold(3)
// x generates [`A, `B, `C], [`D, `E, `F], [`G, `H].

Following is an example to fold elements by 3 with a step of 2:

x = [`A, `B, `C, `D, `E, `F, `G, `H].fold(3, 2)
// x generates [`A, `B, `C], [`C, `D, `E], [`E, `F, `G], [`G, `H].

Creates an iterator that converts element values in the source iterable into strings depending on formatter specifier in format.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that takes the first n elements from the source iterable.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Joins all the elements in the iterable as strings while inserting the specified separator sep and returns the result.

If an element is not a string value, it would be converted to a string before being joined.

Joins all the binary values in the iterable and returns the result.

Returns the length of the iterable.

Creates an iterator that generates element values after applying the specfied function on them. The function must take one argument.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Returns the maximum value in the iterable.

It would return a position index where the maximum value is found when one of the following attributes is specified:

• :index .. an index of the maximum value.
• :last_index .. an index where the maximum value is found at last.
• :indices .. a list of all indices where the maximum value is found.

Calculates an average of elements in the iterable.

It can work on an iterable with elements of type that supports addition and division operators. Below is a list of acceptable value types:

• number
• complex
• rational

Returns the minimum value in the iterable.

It would return a position index where the minimum value is found when one of the following attributes is specified:

• :index .. an index of the minimum value.
• :last_index .. an index where the minimum value is found at last.
• :indices .. a list of all indices where the minimum value is found.

Creates an iterator that converts nil in the source iterable to the specified value.

Creates an iterator that returns skips the first n elements in the source iterable.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Below is an example:

x = [`A, `B, `C, `D, `E, `F, `G, `H].offset(3)
// x generates `D, `E, `F, `G, `H

Calculates a logical OR result of all the values in the iterable.

Creates a binary instance that has packed elements in the iterable according to specifiers in the format.

A specifier has a format of "nX" where X is a format character that represents a packing format and n is a number of packing size. The number can be omitted, and it would be treated as 1 in that case.

Following format characters would take a number value from the argument list and pack them into a binary sequence.

• b .. A one-byte signed number.
• B .. A one-byte unsigned number.
• h .. A two-byte signed number.
• H .. A two-byte unsigned number.
• i .. A four-byte signed number.
• I .. A four-byte unsigned number.
• l .. A four-byte signed number.
• L .. A four-byte unsigned number.
• q .. A eight-byte signed number.
• Q .. A eight-byte unsigned number.
• f .. A float-typed number occupying four bytes.
• d .. A double-typed number occupying eight bytes.

As for them, the packing size n means the number of values to be packed.

Following format characters would take a string value from the argument list and pack them into a binary sequence.

• s .. Packs a sequence of UTF-8 codes in the string. The packing size n means the size of the room in bytes where the character codes are to be packed. Only the sequence within the allocated room would be packed. If the string length is smaller than the room, the lacking part would be filled with zero.
• c .. Picks the first byte of the string and packs it as a one-byte unsigned number. The packing size n means the number of values to be packed.

Following format character would take no value from the argument list.

• x .. Fills the binary with zero. The packing size n means the size of the room in bytes to be filled with zero.

The default byte-order for numbers of two-byte, four-byte and eight-byte depends on the system the interpreter is currently running. You can change it by the following specifiers:

• @ .. System-dependent order.
• = .. System-dependent order.
• < .. Little endian
• > .. Big endian
• ! .. Big endian

You can specify an asterisk character "*" for the number of packing size that picks that number from the argument list.

You can specify encoding name embraced with "{" and "}" in the format to change coding character set while packing a string with format character "s" from UTF-8.

Creates an iterator that iterates elements in the source iterator from top to bottom, and then from bottom to top repeatedly.

The argument n specifies the number of elements the created iterator returns. If omitted, it would iterates elements infinitely.

Below is an example:

x = [`A, `B, `C, `D, `E].pingpong()
// x generates `A, `B, `C, `D, `E, `D, `C, `B, `A, `B, ..

The following attributes specify whether the elements on top and bottom are duplicated:

• :sticky .. Duplicate the top and bottom elements.
• :sticky@top .. Duplicate the top element.
• :sticky@btm .. Duplicate the bottom element.

Below is an example:

x = [`A, `B, `C, `D, `E].pingpong():sticky
// x generates `A, `B, `C, `D, `E, `E, `D, `C, `B, `A, `A, `B, ..

Prints elements to the specified stream.

If omitted, they are printed to the standard output.

Prints items in the iterable by using the format.

Creates an iterable of rank numbers for elements after sorting them.

In default, they are sorted in an ascending order. This means that, if two elements x and y has the relationship of x < y, x would be placed before y. You can change the order by specifying the argument directive with the following symbols:

• `ascend .. Sorts in an ascending order. This is the default.
• `descend .. Sorts in a descending order.

You can also put a function to the argument directive that takes two arguments x and y and is expected to return numbers below:

• x == y .. Zero.
• x < y .. A number less than zero.
• x > y .. A number greater than zero.

When an attribute :stable is specified, the original order shall be kept for elements that are determined as the same.

Evaluates a block with a parameter format |value, accum| and leaves the result as the next accum value.

It returns the final accum value as its result.

Below is an example to calculate summation of the elements:

x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
n = x.reduce(0) {|value, accum| value + accum}
// n is 55

Creates an iterator that replaces the value in the original iterablewith the value of replace.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that iterates elements in the source iterable from tail to top.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that replaces a number with zero if it is less than the specified threshold.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that counts the number of consecutive same value and generates elements in a form of [cnt, value] where cnt indicates how many value appears in a row.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Below is an example:

x = [`A, `A, `B, `C, `C, `C, `D, `D].runlength()
// x generates [2, `A], [1, `B], [3, `C], [2, `D]

Creates an iterator that picks up each element in the iterable since criteria is evaluated as true. You can specify a function object, a list or an iterator as the criteria.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that skips n elements before picking up next element.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Below is an example:

x = [`A, `B, `C, `D, `E, `F, `G, `H].skip(2)
// x generates `A, `D, `G

Creates an iterator that skips nil in the source iterable.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Below is an example:

x = [`A, nil, `C, nil, nil, `F, nil, `H].skipnil()
// x generates `A, `C, `F, `H

Creates an iterator of elements after sorting them.

In default, they are sorted in an ascending order. This means that, if two elements x and y has the relationship of x < y, x would be placed before y. You can change the order by specifying the argument directive with the following symbols:

• `ascend .. Sorts in an ascending order. This is the default.
• `descend .. Sorts in a descending order.

You can also put a function to the argument directive that takes two arguments x and y and is expected to return numbers below:

• x == y .. Zero.
• x < y .. A number less than zero.
• x > y .. A number greater than zero.

When an attribute :stable is specified, the original order shall be kept for elements that are determined as the same. If the argument keys is specified, it would be used as a key instead of element values.

Calculates a standard deviation of elements in the iterable.

Calculates a summation of elements in the iterable.

It can work on an iterable with elements of a value type that supports addition operator. Below is a list of acceptable value types:

• number
• complex
• string
• rational
• timedelta

Creates an iterator that takes the last n elements from the source iterable.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that picks up each element in the list until criteria is evaluated as true. You can specify a function object, a list or an iterator as the criteria.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Calculates a variance of elements in the iterable.

Creates an iterator that picks up each element in the list while criteria is evaluated as true. You can specify a function object, a list or an iterator as the criteria.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Returns a pointer instance that accesses the memory. This result is equivalent to that of calling the method memory#pointer().

Returns the memory size in bytes.

Creates an array@int8 instance that accesses the content of the target memory instance.

Creates an array@uint8 instance that accesses the content of the target memory instance.

Creates an array@int16 instance that accesses the content of the target memory instance.

Creates an array@uint16 instance that accesses the content of the target memory instance.

Creates an array@int32 instance that accesses the content of the target memory instance.

Creates an array@uint32 instance that accesses the content of the target memory instance.

Creates an array@int64 instance that accesses the content of the target memory instance.

Creates an array@uint64 instance that accesses the content of the target memory instance.

Creates an array@float instance that accesses the content of the target memory instance.

Creates an array@double instance that accesses the content of the target memory instance.

Prints a hexadecimal dump from the content of the memory to the standard output. If the argument stream is specified, the result would be output to the stream.

In default, hexadecimal digit are printed with lower-case characters. Specifying an attribute :upper would output them with upper-case characters instead.

Example:

>>> b'A quick brown fox jumps over the lazy dog.'.dump():upper
41 20 71 75 69 63 6B 20 62 72 6F 77 6E 20 66 6F  A quick brown fo
78 20 6A 75 6D 70 73 20 6F 76 65 72 20 74 68 65  x jumps over the
20 6C 61 7A 79 20 64 6F 67 2E                     lazy dog.

Returns a pointer instance that has an initial offset specified by the argument offset. If the argument is omitted, it would return a pointer instance that points to the top of the memory.

If block is specified, it would be evaluated with a block parameter |p:pointer|, where p is the created instance. In this case, the block's result would become the function's returned value.

A symbol instance that represents the operator's type.

Creates an operator instance that is associated with the specified symbol.

If block is specified, it would be evaluated with a block parameter |op:operator|, where op is the created instance. In this case, the block's result would become the function's returned value.

Below is an example to create an operator instance that is associated with the plus symbol.

op = operator(`+)

Associates the operator instance with a procedure described in block that takes values as a block parameter and returns its operation result.

Some operator instances have two forms of expression: unary and binary. This method assignes the procedure to one of them according to how it takes its arguments as below:

• operator#assign(type:expr) .. Assigns procedure to the unary form.
• operator#assign(type_l:expr, type_r:expr) .. Assignes procedure to the binary form.

They take different format of block parameters as below:

• |value| .. For unary form.
• |value_l, value_r| .. For binary form.

Below is an example to assign a procedure to a unary form of operator -.

operator(`-).assign(`string) = {|value|
    // any job
}

Below is an example to assign a procedure to a binary form of operator -.

operator(`-).assign(`string, `number) = {|value_l, value_r|
    // any job
}

Returns a list that contains type expressions that the operator can accept as its arguments.

The argument type takes a symbol `binary or `unary.

• If it's omitted or specified with `binary, the method would return a list of pairs of type expressions for its left element and right one.
• If it's specified with `unary, the method would return a list of type expressions for its single element.

Creates an optimizer instance that uses AdaGrad approach for optimization.

The argument learning_rate indicates the learning rate per one training session.

The argumnent epsilon is a value that is added to the denominator in a divination to avoid zero-divided error. The default is 1e-7.

Creates an optimizer instance that uses gradient descent approach for optimization.

The argument learning_rate indicates the learning rate per one training session.

Creates an optimizer instance that uses AdaGrad approach for optimization.

The argument learning_rate indicates the learning rate per one training session.

The argumnent momentum is a momentum parameter and has a default value of 0.9.

Resets the status of the optimizer, if exists.

Updates array's value by the optimizer calculation using the gradient information in array_grad.

Creates a palette instance.

If block is specified, it would be evaluated with a block parameter |plt:palette|, where plt is the created instance. In this case, the block's result would become the function's returned value.

This function can be called in the following two forms:

• palette(n:number) .. Creates an instance with the specified number of entries. All the entries are initialized with a color of black.
• palette(type:symbol) .. Creates an instance initialized with a pre-defined set of entries associated with the specified symbol.

In the second form, it can take one of the following symbols:

• `basic .. A palette with 16 basic colors that are: color.black, color.maroon, color.green, color.olive, color.navy, color.purple, color.teal, color.gray, color.silver, color.red, color.lime, color.yellow, color.blue, color.fuchsia, color.aqua and color.white.
• `win256 .. A palette with 256 colors defined by Windows.
• `websafe .. A palette with 216 colors that assure to be displayed correctly in any Web environments. It actually has 256 entries though the last 40 entries are initialized with black.

Creates an iterator that iterates each element in the palette.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Returns a color instance in the palette that is the nearest with the specified color.

If the attribute :index is specified, it would return an index of the nearst entry instead of its color instance.

Shrinks the size of the palette to a number powered by two that is enough to contain unique entries. The ordef of existing entries will be kept intact.

Updates palette entries according to color data in an image or a palette.

The order of existing entries will be kept intact. If attribute shrink is specified, the whole size will be shrinked to a number powered by two that is enough to contain unique entries.

The current offset.

Returns the size of data accessible from the current offset.

Returns the entire size of the target binary or memory. This equals to p.offset + p.size where p is a pointer instance.

An instance that is associated with the pointer. Currently, this can be an instance of binary or memory.

Creates a pointer instance that is cloned from the given instance org. You can use this to cast a binary and memory instance to the pointer.

If block is specified, it would be evaluated with a block parameter |ptr:pointer|, where ptr is the created instance. In this case, the block's result would become the function's returned value.

Copies data from src to the target pointer.

If the argument bytes is specified, it would limit the size of data to be copied. Otherwise, all the data pointerd by src is to be copied.

This method returns a reference to the target instance itself.

Copies data from the target pointer to dst.

If the argument bytes is specified, it would limit the size of data to be copied. Otherwise, all the data pointerd by the target instance is to be copied.

This method returns a reference to the target instance itself.

Decodes the content of the pointer as a sequence of string characters using codec and returns the result in string.

If the argument bytes is specified, it would limit the size of data to be decoded. Otherwise, all the data pointerd by the target instance is to be decoded.

If block is specified, it would be evaluated with a block parameter |str:string|, where str is the created instance. In this case, the block's result would become the function's returned value.

Prints a hexadecimal dump from the content of the pointer to the standard output. If the argument stream is specified, the result would be output to the stream.

If the argument bytes is specified, it would limit the size of data to be dumped. Otherwise, all the data pointerd by the target instance is to be dumped.

In default, hexadecimal digit are printed with lower-case characters. Specifying an attribute :upper would output them with upper-case characters instead.

Example:

>>> b'A quick brown fox jumps over the lazy dog.'.p.dump():upper
41 20 71 75 69 63 6B 20 62 72 6F 77 6E 20 66 6F  A quick brown fo
78 20 6A 75 6D 70 73 20 6F 76 65 72 20 74 68 65  x jumps over the
20 6C 61 7A 79 20 64 6F 67 2E                     lazy dog.

Returns a string in which non-URIC characters are converted to percent-encoded string.

For example, b'"Hello"'.p.encodeuri() would return '%22Hello%22'.

If block is specified, it would be evaluated with a block parameter |str:string|, where str is the created instance. In this case, the block's result would become the function's returned value.

Creates an iterator that extracts numbers in size of int8 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of uint8 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of int16 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of uint16 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of int32 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of uint32 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of int64 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of uint64 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of float from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that extracts numbers in size of double from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Put the pointer offset forward by distance. If a negative number is specified for the argument, the offset would be put backward.

An error would occur when the pointer's offset becomes a negative value while it would be no error when the offset exceeds the target maximum range.

This method returns a reference to the target instance itself.

Returns an extracted number in size of int8 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of uint8 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of int16 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of uint16 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of int32 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of uint32 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of int64 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of uint64 from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of float from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Returns an extracted number in size of double from the current pointer position.

In default, it assumes the byte seqeuces are ordered in little-endian. You can specify :be attribute to extract them in big-endian order.

If block is specified, it would be evaluated with a block parameter |n:number|, where n is the created instance. In this case, the block's result would become the function's returned value.

Moves the pointer position to the beginning.

This method returns a reference to the target instance itself.

Converts the binary data into a hexadecimal string.

In default, the result string is a sequence of joined hexadecimal values without any space. You can specify the following attribute to change the format:

• :cstr .. Format of C string.
• :carray .. Format of C array.

Alphabet characters are described in lower characters unless the attribute :upper is specified.

If block is specified, it would be evaluated with a block parameter |str:string|, where str is the created instance. In this case, the block's result would become the function's returned value.

Example:

Code	Result
b'\x01\x23\xab\xcd'.p.hex()	'0123abcd'
b'\x01\x23\xab\xcd'.p.hex():upper	'0123ABCD'
b'\x01\x23\xab\xcd'.p.hex():cstr	'\\x01\\x23\\xab\\xcd'
b'\x01\x23\xab\xcd'.p.hex():carray	'0x01, 0x23, 0xab, 0xcd'

Packs values in the argument list according to specifiers in the format into a binary and adds it to where the pointer points. The pointer offset is automatically incremented by the added length unless :stay attribute is specified.

This method returns a reference to the target instance itself.

A specifier has a format of "nX" where X is a format character that represents a packing format and n is a number of packing size. The number can be omitted, and it would be treated as 1 in that case.

Following format characters would take a number value from the argument list and pack them into a binary sequence.

• b .. One-byte signed number.
• B .. One-byte unsigned number.
• h .. Two-byte signed number.
• H .. Two-byte unsigned number.
• i .. Four-byte signed number.
• I .. Four-byte unsigned number.
• l .. Four-byte signed number.
• L .. Four-byte unsigned number.
• q .. Eight-byte signed number.
• Q .. Eight-byte unsigned number.
• f .. Float-typed number occupying four bytes.
• d .. Double-typed number occupying eight bytes.

As for them, the packing size n means the number of values to be packed.

Following format characters would take a string value from the argument list and pack them into a binary sequence.

• s .. Packs a sequence of UTF-8 codes in the string. The packing size n means the size of the room in bytes where the character codes are to be packed. Only the sequence within the allocated room would be packed. If the string length is smaller than the room, the lacking part would be filled with zero.
• c .. Picks the first byte of the string and packs it as a one-byte unsigned number. The packing size n means the number of values to be packed.

Following format character would take no value from the argument list.

• x .. Fills the binary with zero. The packing size n means the size of the room in bytes to be filled with zero.

The default byte-order for numbers of two-byte, four-byte and eight-byte depends on the system the interpreter is currently running. You can change it by the following specifiers:

• @ .. System-dependent order.
• = .. System-dependent order.
• < .. Little endian
• > .. Big endian
• ! .. Big endian

You can specify an asterisk character "*" for the number of packing size that picks that number from the argument list.

You can specify encoding name embraced with "{" and "}" in the format to change coding character set from UTF-8 while packing a string with format character "s".

Stores the specified number to the current pointer position in size of int8.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of uint8.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of int16.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of uint16.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of int32.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of uint32.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of int64.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of uint64.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of float.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Stores the specified number to the current pointer position in size of double.

In default, it stores the byte sequences in the order of little-endian. You can specify :be sttribute to store them in big-endian order.

This method returns a reference to the target instance itself.

Creates a stream instance with which you can read data from the memory pointerd by the pointer. If block is specified, it would be evaluated with a block parameter |s:stream|, where s is the created instance. In this case, the block's result would become the function's returned value.

Moves the pointer position to the specified offset.

This method returns a reference to the target instance itself.

Moves the pointer position to the end.

This method returns a reference to the target instance itself.

Extracts values from data sequence pointed by the pointer instance according to specifiers in the format and returns a list containing the values.

A specifier has a format of "nX" where X is a format character that represents a packing format and n is a number of packing size. The number can be omitted, and it would be treated as 1 in that case.

Following format characters would extract an integer or float value of specified size from the binary and returns a number value.

• b .. One-byte signed number.
• B .. One-byte unsigned number.
• h .. Two-byte signed number.
• H .. Two-byte unsigned number.
• i .. Four-byte signed number.
• I .. Four-byte unsigned number.
• l .. Four-byte signed number.
• L .. Four-byte unsigned number.
• q .. Eight-byte signed number.
• Q .. Eight-byte unsigned number.
• f .. Float-typed number occupying four bytes.
• d .. Double-typed number occupying eight bytes.

As for them, the packing size n means the number of values to be extracted.

Following format characters would extract a string sequence from the binary and returns a string value.

• s .. Extracts a sequence of UTF-8 codes and returns string instance containing it. The unpacking size n means the size of the room in bytes where the character codes are to be unpacked.
• c .. Extracts a one-byte unsigned number and returns a string instance containing it. The unpacking size n means the number of values to be extracted.

Following format character would not return any value.

• x .. Advances the address by one byte. If the unpacking size n is specifies, it would advance the address by n bytes.

The default byte-order for numbers of two-byte, four-byte and eight-byte depends on the system the interpreter is currently running. You can change it by the following specifiers:

• @ .. System-dependent order.
• = .. System-dependent order.
• < .. Little endian
• > .. Big endian
• ! .. Big endian

You can specify an asterisk character "*" for the number of unpacking size that picks that number from the argument list.

You can specify encoding name embraced with "{" and "}" in the format to change coding character set from UTF-8 while extracting a string with format character "s".

An error occurs if the binary size is smaller than the format reqeusts. If the attribute :nil is specified, nil value would be returned for such a case.

If block is specified, it would be evaluated with a block parameter |list:list|, where list is the created instance. In this case, the block's result would become the function's returned value.

Returns an iterator that extracts values from data pointed by the pointer instance according to specifiers in format.

For detailed information about specifiers, see the help of pointer#unpack().

If block is specified, it would be evaluated with a block parameter |iter:iterator|, where iter is the created instance. In this case, the block's result would become the function's returned value.

Creates a stream instance with which you can append data to the memory pointed by the pointer. If block is specified, it would be evaluated with a block parameter |s:stream|, where s is the created instance. In this case, the block's result would become the function's returned value.

Display name. If the property is a list, a pair of square brackets are appended.

A full name of the property that is prefixed by a name of the class it belongs to.

The property's name.

Returns true if it is readable, false otherwise.

The property's name as a symbol instance.

The value type of the property.

Returns true if it is readable, false otherwise.

Get a help instance assosicated with the property.

The argument lang specifies the language of the document, such as en and ja.

If block is specified, it would be evaluated with a block parameter |help:help|, where help is the created instance. In this case, the block's result would become the function's returned value.

rational(2, 3)
2r / 3
2 / 3r

Creates a rational value from given numerator numer and denominator denom.

If the argument denom is omitted, one is set as its denominator.

If block is specified, it would be evaluated with a block parameter |r:rational|, where r is the created instance. In this case, the block's result would become the function's returned value.

Reduces the rational number by dividing its numerator and denominator by their GCD.

Releases the owership of the semaphore that is grabbed by semaphore#wait().

Forms a critical session by grabbing the semaphore's ownership, executing the block and releasing that ownership. It internally proccesses the same job as semaphore#wait() and semaphore#release() before and after the block execution

Watis for the semaphore being released by other threads, and ghen grabs that ownership.

A codec instance associated with the stream.

Identifier of the stream.

Name of the stream.

Indicates whether the stream is readable.

Status of the stream.

Indicates whether the stream is writable.

sys.stdout << 'Hello World.'

sys.stdout << 'First' << 'Second'

Creates a stream instance from the specified pathname.

The argument mode takes one of the strings that specifies what access should be allowed with the stream. If omitted, the stream would be opened with read mode.

• 'r' .. read
• 'w' .. write
• 'a' .. append

The argument codec specifies a name of the character codec that converts between the stream's character code and UTF-8, which is a code used in the iterpreter's internal process.

If block is specified, it would be evaluated with a block parameter |s:stream|, where s is the created instance. In this case, the block's result would become the function's returned value.

Creates an iterator that reads text from the specified stream line by line.

If attribute :chop is specified, it eliminates an end-of-line character that appears at the end of each line.

This function decodes character codes in the stream using codec instance that is specified when the stream instance is created.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

The codec's encoder in the stream has a feature to add a CR code (0x0d) before a LF code (0x0a) so that the lines are joined with CR-LF codes in the encoded result. This method enables or disables the feature.

• To enable it, call the method with the argument flag set to true or without any argument.
• To disable it, call the method with the argument flag set to false.

Closes the stream.

Returns true if there's no difference between the binary sequences of the target stream instance and that of stream in the argument.

Copies the content in src to the stream dst.

The copy process is done by the following steps:

1. Reads data from stream src into a buffer with the size specified by bytesunit.
2. (1) If block is specified, it would be evaluated with a block parameter |buff:binary| where buff contains the read data. When the block's result is a binary instance, the content would be written to the stream dst. Otherwise, the read data would be written to stream dst. (2) If block is not specified, the read data would be written to stream dst.
3. Continues from step 1 to 2 until data from src runs out.

If the attribute :finalize is specified, some finalizing process such as copying the time stamp and attributes will be applied at the end.

This works the same way as stream#copyfrom() and stream#copyto().

Copies the content in src to target stream instance.

The copy process is done by the following steps:

1. Reads data from stream src into a buffer with the size specified by bytesunit.
2. (1) If block is specified, it would be evaluated with a block parameter |buff:binary| where buff contains the read data. When the block's result is a binary instance, the content would be written to the target stream. Otherwise, the read data would be written to the target stream. (2) If block is not specified, the read data would be written to the target stream.
3. Continues from step 1 to 2 until data from src runs out.

If the attribute :finalize is specified, some finalizing process such as copying the time stamp and attributes will be applied at the end.

This works the same way as stream.copy() and stream#copyto().

Copies the content in the target stream to the stream dst.

The copy process is done by the following steps:

1. Reads data from the target stream into a buffer with the size specified by bytesunit.
2. (1) If block is specified, it would be evaluated with a block parameter |buff:binary| where buff contains the read data. When the block's result is a binary instance, the content would be written to the stream dst. Otherwise, the read data would be written to stream dst. (2) If block is not specified, the read data would be written to stream dst.
3. Continues from step 1 to 2 until data from the target stream runs out.

If the attribute :finalize is specified, some finalizing process such as copying the time stamp and attributes will be applied at the end.

This works the same way as stream.copy() and stream#copyfrom().

The codec's decoder in the stream has a feature to delete a CR code (0x0d) before a LF code (0x0a) so that the lines are joined with LF code in the decoded result. This method enables or disables the feature.

• To enable it, call the method with the argument flag set to true or without any argument.
• To disable it, call the method with the argument flag set to false.

Flushes cached data to the stream.

Reads specified length of data from the stream and returns a binary instance that contains it. This doesn't move the stream's current file position.

Prints out values to the stream instance after converting them to strings.

This function encodes character codes in the string using codec instance that is specified when the stream instance is created.

Prints out values to the stream instance according to formatter specifiers in format.

Refer to the help of printf() function to see information about formatter specifiers.

This function encodes character codes in the string using codec instance that is specified when the stream instance is created.

Prints out values and an end-of-line character to the stream instanceafter converting them to strings.

This function encodes character codes in the string using codec instance that is specified when the stream instance is created.

Reads specified length of data from the stream and returns a binary instance that contains it. If the argument bytes is omitted, all the data available from the stream would be read.

If block is specified, it would be evaluated with a block parameter |buff:binary|, where buff is the created instance. In this case, the block's result would become the function's returned value.

Reads one character from the stream and returns a string instance that contains it.

This method decodes character codes in the stream using codec instance that is specified when the stream instance is created.

If block is specified, it would be evaluated with a block parameter |ch:string|, where ch is the created instance. In this case, the block's result would become the function's returned value.

Reads one line from the stream and returns a string instance that contains it.

If the attribute :chop is specified, it would remove the last new line character from the result. This method decodes character codes in the stream using codec instance that is specified when the stream instance is created.

If block is specified, it would be evaluated with a block parameter |line:string|, where line is the created instance. In this case, the block's result would become the function's returned value.

Creates an iterator that reads text from the specified stream line by line.

The argument nlines specifies how many lines should be read from the stream. If omitted, it would read all the lines.

If attribute :chop is specified, it eliminates an end-of-line character that appears at the end of each line.

This method decodes character codes in the stream using codec instance that is specified when the stream instance is created.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Reads the whole data in the stream as a text sequence and returns a string instance that contains it. This method decodes character codes in the stream using codec instance that is specified when the stream instance is created.

If block is specified, it would be evaluated with a block parameter |text:string|, where text is the created instance. In this case, the block's result would become the function's returned value.

Seeks the current file position to the offset specified by the argument offset.

The argument origin specifies the meaning of offset value as follows:

• set` ... `offset` is an absolute offset from the begining of the stream.
• cur` ... `offset` is a relative offset from the current position.

This method returns the target stream instance itself.

Sets codec instance to the target stream. If nil is specified for the argument, the current codec instance would be removed.

This method returns the target stream instance itself.

Returns the current file position at which read/write operation works.

Writes binary data pointer by ptr to the stream. The argument bytes limits the number of data that is to be written to the stream.

'Hello World'

"Hello World"

R"""
first line
second line
third line
"""

Align the string to the left, right or center within the specified width and returns the result.

The following attributes specify the alignment position:

• :center .. Aligns to the center. This is the default.
• :left .. Aligns to the left
• :right .. Aligns to the right

If the string width is narrower than the specified width, nothing would be done.

It uses a string specified by the argument padding to fill lacking spaces. If omitted, a white space is used for padding.

This method takes into account the character width based on the specification of East Asian Width. A kanji-character occupies two characters in width.

Converts the string into binary instance.

Returns a string that capitalizes the first character.

Returns a string that removes a last character.

If an attribute :eol is specified, only the end-of-line character shall be removed. In this case, if the end-of-line has a sequence of CR-LF, CR code shall be removed as well.

Returns a string in which percent-encoded characters are decoded.

Creates an iterator generating strings of each character in the original one.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator generating strings of each line in the original one.

In default, end-of-line characters are involved in the result. You can eliminates them by specifying :chop attribute.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Evaluates a string that contains embedded scripts and renders the result to the specified stream.

If the stream is omitted, the function returns the rendered result as a string.

Calling this method is equivalent to calling a method string#template() to create a template instance on which a method template#render() is applied afterward.

Encodes the string with the given codec and return the result as a binary.

Returns a string in which non-URIC characters are percent-encoded.

Returns true if the string ends with suffix.

If attribute :rest is specified, it returns the rest part if the string ends with suffix, or nil otherewise. You can specify a bottom position for the matching by an argument endpos.

With an attribute :icase, character cases are ignored while matching.

Converts some characters into HTML entity symbols. If attribute :quote is specified, a double-quotation character would be converted to an entity symbol """.

Finds a sub string from the string and returns its position.

Number of position starts from zero. You can specify a position to start finding by an argument pos. It returns nil if finding fails.

With an attribute :icase, case of characters are ignored while finding.

When an attribute :rev, finding starts from tail of the string

Creates an iterator that folds the source string by the specified length.

The argument step specifies the length of advancement for the next folding point. If omitted, it would be the same amount as len.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Creates an iterator that folds the source string by the specified width.

This method takes into account the character width based on the specification of East Asian Width.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Taking the string instance as a printf-styled formatter string, it converts values into a string depending on formatter specifiers in it.

Returns true if the string is empty.

Extracts the specified length of string from left of the source string.

If the argument is omitted, it would return whole the source string.

Returns the length of the string in characters.

Converts upper-case to lower-case characters.

Extracts the specified length of string from the position pos and returns the result.

If the argument len is omitted, it returns a string from pos to the end. The number of an argument pos starts from zero.

Below are examples:

'Hello world'.mid(3, 2) // 'lo'
'Hello world'.mid(5)    // 'world'

Prints out the string to the specified stream.

If the argument is omitted, it would print to the standard output.

Prints out the string and a line-break to the specified stream.

If the argument is omitted, it would print to the standard output.

Returns a stream instance that reads the string content as a binary sequence.

If block is specified, it would be evaluated with a block parameter |s:stream|, where s is the created instance. In this case, the block's result would become the function's returned value.

Replaces sub strings that matches the string match with a string specified by sub and returns the result.

The argument count limits the maximum number of substitution. If omitted, there's no limit of the work.

With an attribute :icase, character cases are ignored while matching strings.

If block is specified, it would be evaluated with a block parameter |result:string, replaced:boolean|, where result is the result string and replaced indicates if there is any change between the result and its original string. In this case, the block's result would become the function's returned value.

Replaces string parts according to a list of pairs of a matching and a substituting string and returns the result.

The argument map is a list of match-substitution paris like [match1, sub1, match2, sub2, ..] with which a sub string that matches matchn would be replaced with subn.

The argument count limits the maximum number of substitution. If omitted, there's no limit of the work.

With an attribute :icase, character cases are ignored while matching strings.

If block is specified, it would be evaluated with a block parameter |result:string, replaced:boolean|, where result is the result string and replaced indicates if there is any change between the result and its original string. In this case, the block's result would become the function's returned value.

Extracts the specified length of string from right of the source string.

If the argument is omitted, it would return whole the source string.

Creates an iterator generating sub strings extracted from the original one separated by a specified string sep. With an attribute :icase, character cases are ignored while finding the separator.

In default, this returns an iterator as its result value. Specifying the following attributes would customize the returned value:

• :iter .. An iterator. This is the default behavior.
• :xiter .. An iterator that eliminates nil from its elements.
• :list .. A list.
• :xlist .. A list that eliminates nil from its elements.
• :set .. A list that eliminates duplicated values from its elements.
• :xset .. A list that eliminates duplicated values and nil from its elements.

See the chapter of Mapping Process in Gura Language Manual for the detail.

If a block is specified, it would be evaluated repeatingly with block parameters |value, idx:number| where value is the iterated value and idx the loop index starting from zero. In this case, the last evaluated value of the block would be the result value. If one of the attributes listed above is specified, an iterator or a list of the evaluated value would be returned.

Returns true if the string starts with prefix.

If attribute :rest is specified, it returns the rest part if the string starts with prefix, or nil otherewise. You can specify a top position for the matching by an argument pos.

With an attribute :icase, character cases are ignored while matching.

Returns a string that removes space characters on the left, the right or the both sides of the original string.

The following attributes would specify which side of spaces should be removed:

• :both .. Removes spaces on both sides. This is the default.
• :left .. Removes spaces on the left side.
• :right .. Removes spaces on the right side.

Parses the content of the string as a text containing embedded scripts and returns a template instance.

Convers the string into a symbol.

Register a procedure evaluated when a string literal appears with a suffix symbol "$", which is meant to translate the string into another language.

The procedure is described in block takes a block parameter |str:string| where str is the original string, and is expected to return a string translated from the original.

Converts escape sequences into readable characters.

Converts lower-case to upper-case characters.

Returns the width of the string.

This method takes into account the character width based on the specification of East Asian Width. For example, a kanji-character of Japanese occupies two characters in width.

Converts zenkaku to hankaku characters.

suffixmgr(`string).assign(`X) {|body| body.upper()}

'hello world'X

Creates a reference to one of two suffix managers, number and string.

• The number suffix manager works with number literals.
• The string suffix manager works with string literals.

Specify the argument type with a symbol `number for a number suffix manager and `string for a string suffix manager.

Assigns a procedure to a specified symbol in the suffix manager. The procedure is provided by the block that takes a block parameter |value| where value comes from the preceded literal.

An error occurs if the same suffix symbol has already been assigned. Specifying :overwrite attribute will forcibly overwrite an existing assignment.

Evaluate a symbol object.

Returns the length of the symbol in characters.

Returns the width of the symbol.

This method takes into account the character width based on the specification of East Asian Width. For example, a kanji-character of Japanese occupies two characters in width.

Creates a template instance.

If the stream src is specified, the instance would be initialized with the parsed result of the script-embedded text from the stream.

Following attributes would customize the parser's behavior:

• :lasteol
• :noindent

Creates a template instance by parsing a script-embedded text in a string.

Following attributes would customize the parser's behavior:

• :lasteol
• :noindent

Creates a template instance by parsing a script-embedded text from a stream.

Following attributes would customize the parser's behavior:

• :lasteol
• :noindent

Renders stored content to the specified stream.

If the stream is omitted, the function returns the rendered result as a string.

Creates a template block which content is supposed to be replaced by a derived template.

This method is called by template directive ${=block()} during both the initialization and presentation phase of a template process.

• Initialization: Creates a template block from the specified block that is then registered in the current template with the specified symbol.
• Presentation: Evaluates a template block registered with the specified symbol.

Consider an example. Assume that a block associated with symbol `foo is declared in a template file named base.tmpl as below:

[base.tmpl]

Block begins here.
${=block(`foo)}
Content of base.
${end}
Block ends here.

This template renders the following result:

Block begins here.
Content of derived.
Block ends here.

Below is another template named derived.tmpl that devies from base.tmpl and overrides the block `foo.

[derived.tmpl]

${=extends('base.tmpl')}

${=block(`foo)}
Content of derived.
${end}

This template renders the following result:

Block begins here.
Content of derived.
Block ends here.

Calls a template macro that has been created by directive ${=define}.

This method is called by template directive ${=call()} during the presentation phase of a template process.

Below is an exemple to call a template macro:

${=call(`show_person, 'Harry', 24)}

This method would return nil if a line-break character is rendered at last and would return a null string otherwise.

Creates a template macro from the specified block, which is supposed to be called by ${=call} directive, and associates it with the specified symbol.

This method is called by template directive ${=define()} during the initialization phase of a template process.

Below is an example to create a template macro:

${=define(`show_person, name:string, age:number)}
${name} is ${age} years old.
${end}

Renders the specified template at the current position.

This method is called by template directive ${=embed()} during the presentation phase of a template process.

Below is an example to embed a template file named foo.tmpl.

${=embed('foo.tmpl')}

As the template rendered by this method runs in a different context from the current one, macros and blocks that it defines are not reflected to the current context.

This method would return nil if a line-break character is rendered at last and would return a null string otherwise.

Declares the current template as a derived one from the specified template.

This method is called by template directive ${=extends()} during the initialization phase of a template process.

The directive must appear in a template only once. An error occurs if the current template has already derived from another template.

Below is an example to declare the current template as one derived from base.tmpl.

${=extends('base.tmpl')}

Evaluates a template block registered with the specified symbol in a template from which the current template has derived.

This method is called by template directive ${=super()} during the presentation phase of a template process. The directive is intended to be used within a directive ${=block()}.

Consider an example. Assume that a block associated with symbol `foo is declared in a template named base.tmpl as below:

[base.tmpl]

Block begins here.
${=block(`foo)}
Content of base.
${end}
Block ends here.

This template renders the following result:

Block begins here.
Content of derived.
Block ends here.

Below is another template named derived.tmpl that devies from base.tmpl and overrides the block `foo.

[derived.tmpl]

${=extends('base.tmpl')}

${=block(`foo)}
${=super(`foo)}
Content of derived.
${end}

This template renders the following result:

Block begins here.
Content of base.
Content of derived.
Block ends here.

Offset of days.

Offset of seconds.

Offset of micro seconds.

Returns a timedelta instance with specified values. The instance actually holds properties of days, secs and usecs.

scheme:[//[user:password@]host:port]][/]path[?query][#fragment]

Host part in the URI.

Misc part in the URI.

Password part in the URI.

Port part in the URI.

Scheme part in the URI.

URL path part in the URI, which contains the path, query and fragment part.

User part in the URI.

Creates uri instance.

If the argument str is specified, it would be parsed as a URI which is stored in the instance.

If omitted, the instance would be initialized as an empty one.

Returns the fragment part contained in the URI path.

Returns the path part contained in the URI path.

Returns a dict instance that is made from the query part in the URI path.

This is a utility function to parse a query string and return a dict instance that contains key-value pairs for the query.

A value of X.

A value of Y.

A value of Z.

Creates a vertex instance that has the given coordinates x, y and z. The argument z is optional and set to zero if omitted.

If block is specified, it would be evaluated with a block parameter |v:vertex|, where v is the created instance. In this case, the block's result would become the function's returned value.

Calculates cross product between v1 and v2 and returns the result as a vertex instance.

Calculates dot product between v1 and v2 and returns the result as a number instance.

Creates a list that contains coordinate values [x, y, z] of the target vertex.

If block is specified, it would be evaluated with a block parameter |list:list|, where list is the created instance. In this case, the block's result would become the function's returned value.

Calculates a normal vector for a face that consists of three vertices given and returns it as a vertex instance.

In default, it returns a vector before being regulated to have a length of one. Specifying the attribute :unit would apply the calculation.

If block is specified, it would be evaluated with a block parameter |v:vertex|, where v is the created instance. In this case, the block's result would become the function's returned value.

Creates a vertex that is rotated from the target vertex around X-axis by the specified angle in radian. It would be rotated in a direction of tilting Y-axis toward Z-axis.

If the attribute :deg is specified, you can specify the angle in degree unit.

If block is specified, it would be evaluated with a block parameter |v:vertex|, where v is the created instance. In this case, the block's result would become the function's returned value.

Creates a vertex that is rotated from the target vertex around Y-axis by the specified angle in radian. It would be rotated in a direction of tilting Z-axis toward X-axis.

If the attribute :deg is specified, you can specify the angle in degree unit.

If block is specified, it would be evaluated with a block parameter |v:vertex|, where v is the created instance. In this case, the block's result would become the function's returned value.

Creates a vertex that is rotated from the target vertex around Z-axis by the specified angle in radian. It would be rotated in a direction of tilting X-axis toward Y-axis.

If the attribute :deg is specified, you can specify the angle in degree unit.

If block is specified, it would be evaluated with a block parameter |v:vertex|, where v is the created instance. In this case, the block's result would become the function's returned value.

Creates a vertex that is translated from the target vertex by the specified offsets tx, ty and tz.

If block is specified, it would be evaluated with a block parameter |v:vertex|, where v is the created instance. In this case, the block's result would become the function's returned value.