SYNOPSIS
        mixed * map(mixed *arg, string func, string|object ob, mixed extra...)
        mixed * map(mixed *arg, closure cl, mixed extra...)
        mixed * map(mixed *arg, mapping m [, int idx])

        mixed * map(struct arg, string func, string|object ob, mixed extra...)
        mixed * map(struct arg, closure cl, mixed extra...)
        mixed * map(struct arg, mapping m [, int idx])

        mapping map(mapping arg, string func, string|object ob, mixed extra...)
        mapping map(mapping arg, closure cl, mixed extra...)

        string map(string arg, string func, string|object ob, mixed extra...)
        string map(string arg, closure cl, mixed extra...)
        string map(string arg, mapping m [, int idx])

BESCHREIBUNG
        Ruft die Funktion <ob>-><func>() bzw. die Closure <cl> fuer jedes
        Element des Strings, Arrays, Mappings oder der Struktur <arg> auf
        und liefert ein Resultat, das aus den verschiedenen Rueckgabewerten
        erstellt wurde.

        Wurde <ob> nicht angegeben, oder ist es weder ein String noch ein
        Objekt, wird stattdessen this_object() verwendet.

        Ist <arg> ein Array, ein String oder eine Struktur, wird die Funktion
        mit jedem Element des Arrays als erstem Parameter aufgerufen, gefolgt
        von den <extra> Argumenten. Das Resultat der Efun ist ein Array, das
        die Rueckgabewerte der Funktionsaufrufe enthaelt. Man koennte die
        Operation map() deshalb umschreiben als:

            foreach(index) result[index] = ob->func(arg[index], extra...)

        Ist <arg> ein Array, ein String oder eine Struktur, und wurde statt
        einer Funktion ein Mapping angegeben, so liefert map() ein Array mit
        den Werten, die im Mapping an Stelle der urspruenglichen Werte stehen,
        bzw. mit den Originalwerten, wenn fuer sie kein Mappingeintrag
        existiert. Ist <idx> angegeben, so wird die entsprechende Spalte des
        Mappings verwendet. Mit anderen Worten:

            foreach(index)
                if (arg[index] ist ein Key in <arg>)
                    result[index] = map[arg[index]] oder map[arg[index]]
                else
                    result[index] = arg[index]

        Ist <arg> ein Mapping, wird die Funktion fuer jeden Key des Mappings
        als erstem Parameter und den Datenwerten (sofern vorhanden) als
        zusaetzliche Argumente aufgerufen, gefolgt von den <extra> Argumenten.
        Die <extra> Argumente duerfen keine geschuetzten Referenzen enthalten
        (wie z.B. &(i[0])). Das Ergebnis der Efun ist ein Mapping, das die
        Resultate der Funktionsaufrufe als Zuordnung zum jeweiligen Key
        enthaelt.

        Abhaengig von der Breite des Mappings <arg>, kann die Operation
        umschrieben werden als:

            foreach (key in arg)
                switch (widthof(arg))
                case 0:
                    result[key] = ob->func(key, 0, extra...)
                case 1:
                    result[key] = ob->func(key, arg[key], extra...)
                else  :
                    result[key] = ob->func( key
                                        , ({ arg[key,0] ...arg[key,width-1] })
                                        , extra...)

        Der Vorteil dieses Ansatzes ist, dass beide Arten von mehrdimensionalen
        Mappings (Mappings mit mehreren Werten pro Key und Mappings von Arrays)
        gleich behandelt werden koennen.

BEISPIELE
        arr = ({ 1, 2, 3, 4 });
        m = ([ 1:-1, 3:-3 ]);

        map(arr, #'%, 2)  --> liefert ({ 1, 0, 1, 0 })
        map(arr, m)       --> liefert ([ -1, 2, -3, 4 })

ANMERKUNGEN
        map() auf Arrays angewandt verhaelt sich wie map_array(), auf Mappings
        angewandt hingegen verhaelt es sich wie eine Verallgemeinerung von
        map_indices().

GESCHICHTE
        Eingefuehrt in LDMud 3.2.6, loest map_array() ab.
        LDMud 3.2.8 fuehrt neu die Moeglichkeit ein, ein Array durch ein
        Mapping zu mappen.
        LDMud 3.3.439 fuehrt map() fuer Strings ein.
        LDMud 3.3.719 fuehrt den <idx>-Parameter fuer mappen mit Mappings ein.

SIEHE AUCH
        filter(E), filter_indices(E), map_indices(E), map_objects(E)
