SYNOPSIS
        mixed  arr[index];
        int    str[index];

        mixed * arr[from..to];
        string  str[from..to];

BESCHREIBUNG
        Liefert ein Element aus einem Array oder String (erste Form), oder
        eine Teilmenge (zweite Form).

        Die Indizes <index>, <from> und <to> sind durchnummeriert von 0 bis
        strlen(<str>)-1 bzw. sizeof(<arr>)-1. Wenn ein <index> als '<wert'
        geschrieben wird, wird der Wert vom Ende des Stings / Arrays her
        gezaehlt. Dabei wird nummeriert von 1 bis strlen(<str>) bzw.
        sizeof(<arr>). Wird <from> weggelassen, beginnt die Teilmenge mit
        dem ersten Element. Wird <to> weggelassen, endet die Teilmenge mit
        dem letzten Element.

        In der ersten Form muss <index> innerhalb der Grenzen des Strings /
        Arrays sein, sonst wird ein Laufzeitfehler (RTE) verursacht. In der
        zweiten Form werden die Indizes an die Groesse des Strings / Arrays
        angepasst. Wenn <from> groesser ist als <to> oder beide ausserhalb
        der Groesse des Strings / Arrays liegen, wird ein leerer String ""
        bzw. ein leeres Array ({}) zurueck geliefert.

        Die Notation als Closure ist entsprechend:

            [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 })

BEISPIELE
        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"

GESCHICHTE
        slice_array() ist die alte Form der []-Operatoren fuer Arrays,
        extract() ist die alte Form der []-Operatoren fuer Strings.
        BEIDE VARIANTEN SIND VERALTET, WERDEN NICHT MEHR UNTERSTUETZT UND
        SOLLTEN DESHALB NICHT MEHR VERWENDET WERDEN.

        Die Syntax fuer 'rueckwaerts zaehlen vom letzten Element' hat sich von
        Version 3.1.J zu 3.1.K geaendert von '-1' zu '<1'. Auch ist seit dann
        foo[0..-1] ein leeres Array bzw. ein leerer String.

SIEHE AUCH
        member(E), sizeof(E), slice_array(E)