doc/efun/[]

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)