These restrictions on the use of `read()' without an explicit argument preserve the following simple invariant: if input is being read from a player, it is for the task started by the last command that player typed. This invariant adds responsibility to the programmer, however.
If your program calls another verb before doing a `read()', then that verb must also not suspend. As an example, consider the following, which refers to the verbs programmed in the `suspend()' example in `help suspend()':

    .program   #0:read_twice_A
    s = read();        /* success depends on programmer's permissions */
    #0:callee_A();     /* callee_A does not suspend */
    t = read();        /* success depends on programmer's permissions */
    .

    .program   #0:read_twice_B
    s = read();        /* success depends on programmer's permissions */
    #0:callee_B();     /* callee_B does suspend */
    t = read();        /* fails, returning E_PERM */

The references to <object> in the parent/children and location/contents hierarchies are updated to use the new object number, and any verbs, properties and/or objects owned by <object> are also changed to be owned by the new object number. The latter operation can be quite time consuming if the database is large. No other changes to the database are performed; in particular, no object references in property values or verb code are updated.

    index("foobar", "o")       	 	=>   2
    rindex("foobar", "o")       	=>   3
    index("foobar", "x")        	=>   0
    index("foobar", "oba")      	=>   3
    index("Foobar", "foo", 1)   	=>   0

The list that `match()' (`rmatch()') returns contains the details about the match made. The list is in the form:

     {<start>, <end>, <replacements>, <subject>}

The <replacements> list is always nine items long, each item itself being a list of two numbers, the start and end indices in <subject> matched by some parenthesized sub-pattern of <pattern>. The first item in <replacements> carries the indices for the first parenthesized sub-pattern, the second item carries those for the second sub-pattern, and so on.
If there are fewer than nine parenthesized sub-patterns in <pattern>, or if some sub-pattern was not used in the match, then the corresponding item in <replacements> is the list {0, -1}. See the discussion of `%)' in `help regular-expressions', for more information on parenthesized sub-patterns.

   match("foo", "f*o")          	=>  {1, 2, {{0, -1}, ...}, "foo"}
   match("foo", "fo*")          	=>  {1, 3, {{0, -1}, ...}, "foo"}
   match("foobar", "o*b")       	=>  {2, 4, {{0, -1}, ...}, "foobar"}
   rmatch("foobar", "o*b")      	=>  {4, 4, {{0, -1}, ...}, "foobar"}
   match("foobar", "f%(o*%)b")  	=>  {1, 4, {{2, 3}, {0, -1}, ...}, "foobar"}

    "<major>.<minor>.<release>"

The major version number changes very slowly, only when existing MOO code might stop working, due to an incompatible change in the syntax or semantics of the programming language, or when an incompatible change is made to the database format.

The minor version number changes more quickly, whenever an upward-compatible change is made in the programming language syntax or semantics. The most common cause of this is the addition of a new kind of expression, statement, or built-in function.

If <value> is true, then <object> gains (or keeps) ``player object'' status: it will be an element of the list returned by `players()', the expression `is_player(<object>)' will return true, and users can connect to <object> by name when they log into the server.

    {<owner>, <perms>}

    {<dobj>, <prep>, <iobj>}

If <object> is not valid, then `E_INVARG' is returned. If <object> does not define a verb named <verb-name>, then `E_VERBNF' is returned.
If the programmer does not have read (write) permission on the verb in question, then `verb_code()' (`set_verb_code()') returns `E_PERM'.
If the programmer is not, in fact, a programmer, then `E_PERM' is returned.

    {<owner>, <perms>, <names>}

    setadd({1, 2, 3}, 3)         	=>   {1, 2, 3}
    setadd({1, 2, 3}, 4)         	=>   {1, 2, 3, 4}
    setremove({1, 2, 3}, 3)      	=>   {1, 2}
    setremove({1, 2, 3}, 4)      	=>   {1, 2, 3}
    setremove({1, 2, 3, 2}, 2)   	=>   {1, 3, 2}

    setadd({1, 2, 3}, 3)         	=>   {1, 2, 3}
    setadd({1, 2, 3}, 4)         	=>   {1, 2, 3, 4}
    setremove({1, 2, 3}, 3)      	=>   {1, 2}
    setremove({1, 2, 3}, 4)      	=>   {1, 2, 3}
    setremove({1, 2, 3, 2}, 2)   	=>   {1, 3, 2}

string_hash(x) == string_hash(y)

then, almost certainly

equal(x, y)

    strsub("%n is a fink.", "%n", "Fred")   	=>   "Fred is a fink."
    strsub("foobar", "OB", "b")             	=>   "fobar"
    strsub("foobar", "OB", "b", 1)          	=>   "foobar"

In <template>, the strings `%1' through `%9' will be replaced by the text matched by the first through ninth parenthesized sub-patterns when `match()' or `rmatch()' was called. The string `%0' in <template> will be replaced by the text matched by the pattern as a whole when `match()' or `rmatch()' was called.

     subs = match("*** Welcome to LambdaMOO!!!", "%(%w*%) to %(%w*%)");
     substitute("I thank you for your %1 here in %2.", subs)
             =>   "I thank you for your Welcome here in LambdaMOO."

In some sense, this function forks the `rest' of the executing task.
However, there is a major difference between the use of `suspend(<seconds>)' and the use of the `fork (<seconds>)'. The `fork' statement creates a new task (a "forked task") while the currently-running task still goes on to completion, but a `suspend()' suspends the currently-running task (thus making it into a "suspended task"). This difference may be best explained by the following examples, in which one verb calls another:

    .program   #0:caller_A
    #0.prop = 1;
    #0:callee_A();
    #0.prop = 2;
    .

    .program   #0:callee_A
    fork(5)
      #0.prop = 3;
    endfork
    .

    .program   #0:caller_B
    #0.prop = 1;
    #0:callee_B();
    #0.prop = 2;
    .

    .program   #0:callee_B
    suspend(5);
    #0.prop = 3;
    .

Now consider `#0:caller_B', which calls `#0:callee_B' instead of `#0:callee_A'. This task would assign 1 to `#0.prop', call `#0:callee_B', and suspend. Five seconds later, if the suspended task had not been killed, then it would resume; it would assign 3 to `#0.prop', return to `#0:caller', and assign 2 to `#0.prop', ending the task. So, the final value of `#0.prop' (i.e., the value after more than 5 seconds) would be 2.

A suspended task, like a forked task, can be described by the `queued_tasks()' function and killed by the `kill_task()' function. Suspending a task does not change its task id. A task can be suspended again and again by successive calls to `suspend()'.

  tofloat(34)       =>  34.0
  tofloat(#34)      =>  34.0
  tofloat("34")     =>  34.0
  tofloat("34.7")   =>  34.7
  tofloat(E_TYPE)   =>  1.0

    toint(34.7)        =>   34
    toint(-34.7)       =>   34
    toint(#34)         =>   34
    toint("34")        =>   34
    toint("34.7")      =>   34
    toint(" - 34  ")   =>  -34
    toint(E_TYPE)      =>    1

Examples:
toliteral(43)                       =>  "43"
toliteral(1.0/3.0)                  =>  "0.33333333333333"
toliteral(#17)                      =>  "#17"
toliteral(E_PERM)                   =>  "E_PERM"
toliteral({"A", "B", {"C", 123}})   =>  "{\"A\", \"B\", {\"C\", 123}}"

    tonum(#34)         =>   34
    tonum("34")        =>   34
    tonum(" - 34  ")   =>  -34
    tonum(E_TYPE)      =>    1

    toobj("34")       	=>   #34
    toobj("#34")      	=>   #34
    toobj("foo")      	=>   #0
    toobj({1, 2})     	-error->   E_TYPE

    tostr(17)                  		=>   "17"
    tostr(#17)                 		=>   "#17"
    tostr("foo")               		=>   "foo"
    tostr({1, 2})              		=>   "{list}"
    tostr(E_PERM)              	=>   "Permission denied"
    tostr("3 + 4 = ", 3 + 4)   	=>   "3 + 4 = 7"

    if (typeof(x) == LIST) ...

and not like this:

    if (typeof(x) == 3) ...

    valid(#0)    	=>   1
    valid(#-1)   	=>   0

    {<dobj>, <prep>, <iobj>}

    verb_args($container, "take")
                        =>   {"any", "out of/from inside/from", "this"}
    set_verb_args($container, "take", {"any", "from", "this"})

If <object> is not valid, then `E_INVARG' is returned. If <object> does not define a verb named <verb-name>, then `E_VERBNF' is returned. If the programmer does not have read (write) permission on the verb in question, then `verb_code()' (`set_verb_code()') returns `E_PERM'. If the programmer is not, in fact, a programmer, then `E_PERM' is returned.