diff --git "a/doc/efun/\133\135" "b/doc/efun/\133\135"
new file mode 100644
index 0000000..a59696a
--- /dev/null
+++ "b/doc/efun/\133\135"
@@ -0,0 +1,66 @@
+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"
+
+AENDERUNGEN
+        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)