SYNOPSIS
	mixed   arr[index]
	int     str[index]

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

DESCRIPTION
	Return one element from a string/array (first form), or a
	slice (substring resp. subarray) of the string/array (second form).

	The indexes <index>, <from> and <to> are numbered 0 to
	strlen(str)-1 resp. sizeof(arr)-1 .
	If an index is written '<value', the value is counted from the
	end of the string/array and is numbered 1 to strlen(str) resp.
	sizeof(arr).
	If <from> is omitted, it defaults to the beginning of the
	string/array.
	If <to> is omitted, it defaults to the beginning of the
	string/array.
	
	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. 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 })
	  [from..to]   -> ({'#[..],   arr, from, to })
	  [<from..to]  -> ({'#[<..],  arr, from, to })
	  [from..<to]  -> ({'#[..<],  arr, from, to })
	  [<from..<to] -> ({'#[<..<], arr, 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.

SEE ALSO
	member_array(E), sizeof(E)
