| SYNOPSIS |
| mixed arr[index] |
| int str[index] |
| |
| mixed * arr[from .. to] |
| string str[from .. to] |
| mixed m[key, from .. to] |
| |
| DESCRIPTION |
| Return one element from a string/array (first form), or a slice |
| (substring resp. subarray) of a string/array/mapping (second form). |
| |
| The indexes <index>, <from> and <to> are numbered 0 to |
| strlen(str)-1, sizeof(arr)-1 resp. widthof(m)-1. |
| |
| If an index is written '<value', the value is counted from the |
| end of the string/array/mapping and is numbered 1 to strlen(str), |
| sizeof(arr) resp. widthof(m). |
| |
| If an index is written '>value', the value is counted from the |
| end of the string/array/mapping if it is negative (starting with |
| -1 for the last element), and from the beginning if it is positive |
| (starting with 0 for the first element). |
| |
| If <from> is omitted, it defaults to the beginning of the |
| string/array/mapping. |
| If <to> is omitted, it defaults to the beginning of the |
| string/array/mapping. |
| |
| In the first form, the <index> must be within the bounds of |
| the string/array, or a runtime error occurs. |
| In the second form, the indexes will be fitted to the bounds of |
| the string/array/mapping. If <from> is greater than <to>, or both |
| outside the bounds, an empty string/array ("" resp. ({})) will |
| be returned. |
| |
| The closure notation is straightforward: |
| |
| [index] -> ({'#[, arr, index }) |
| [<index] -> ({'#[<, arr, index }) |
| [>index] -> ({'#[>, arr, index }) |
| [from..to] -> ({'#[..], arr, from, to }) |
| [<from..to] -> ({'#[<..], arr, from, to }) |
| [from..<to] -> ({'#[..<], arr, from, to }) |
| [<from..<to] -> ({'#[<..<], arr, from, to }) |
| [>from..to] -> ({'#[>..], arr, from, to }) |
| [from..>to] -> ({'#[..>], arr, from, to }) |
| [>from..<to] -> ({'#[>..<], arr, from, to }) |
| [<from..>to] -> ({'#[<..>], arr, from, to }) |
| [>from..>to] -> ({'#[>..>], arr, from, to }) |
| [key,index] -> ({'#[,], m, index }) |
| [key,<index] -> ({'#[,<], m, index }) |
| [key,>index] -> ({'#[,>], m, index }) |
| [key,from..to] -> ({'#[,..], m, from, to }) |
| [key,<from..to] -> ({'#[,<..], m, from, to }) |
| [key,from..<to] -> ({'#[,..<], m, from, to }) |
| [key,<from..<to] -> ({'#[,<..<], m, from, to }) |
| [key,>from..to] -> ({'#[,>..], m, from, to }) |
| [key,from..>to] -> ({'#[,..>], m, from, to }) |
| [key,>from..<to] -> ({'#[,>..<], m, from, to }) |
| [key,<from..>to] -> ({'#[,<..>], m, from, to }) |
| [key,>from..>to] -> ({'#[,>..>], m, from, to }) |
| |
| EXAMPLES |
| foo = ({ 1, 2, 3, 4 }); str = "test"; |
| |
| foo[1] -> 1 str[1] -> 'e' == 101 |
| foo[1..2] -> ({ 2, 3 }) str[1..2] -> "es" |
| foo[2..1] -> ({ }) str[2..1] -> "" |
| foo[0..<2] -> ({ 1, 2 }) str[0..<2] -> "tes" |
| foo[..<2] -> ({ 1, 2 }) str[..<2] -> "tes" |
| foo[<3..] -> ({ 2, 3, 4 }) str[<3..] -> "est" |
| |
| foo[1] = 5 -> foo == ({ 1, 5, 3, 4 }) |
| foo[1..2] = ({ 5, 6, 7 }) -> foo == ({ 1, 5, 6, 7, 4 }) |
| foo[1..2] = ({ }) -> foo == ({ 1, 4 }) |
| |
| str[1] = 'a' -> str == "tast" |
| str[1..2] = "bar" -> str == "tbart" |
| str[1..2] = "" -> str == "tt" |
| |
| HISTORY |
| slice_array() is the old form of the [] operator on arrays. |
| extract() is the old form of the [] operator on strings. |
| Both ARE NO LONGER SUPPORTED and should not be used anymore! |
| |
| The syntax for ``counting from last element'' has changed |
| between versions 3.1.J and 3.1.K from ``-1'' to ``<1''. |
| foo[0..-1] is now an empty string resp. array. |
| |
| LDMud 3.3 introduced the '>' indexing method. |
| |
| LDMud 3.6.6 introduced range indexing for mappings. |
| |
| SEE ALSO |
| member(E), sizeof(E) |
| |