There are only a few kinds of values that MOO programs can manipulate:

integers (in a specific, large range)

real numbers (represented with floating-point numbers)

strings (of characters)

objects (in the virtual reality)

errors (arising during program execution)

lists (of all of the above, including lists)

MOO supports the integers from -2^31 (that is, negative two to the power
of 31) up to 2^31 - 1 (one less than two to the power of 31); that's
from -2147483648 to 2147483647, enough for most purposes. In MOO
programs, integers are written just as you see them here, an optional minus
sign followed by a non-empty sequence of decimal digits. In particular, you
may not put commas, periods, or spaces in the middle of large integers, as we
sometimes do in English and other natural languages (e.g., `2,147,483,647').

Real numbers in MOO are represented as they are in almost all other programming
languages, using so-called floating-point numbers. These have certain
(large) limits on size and precision that make them useful for a wide range of
applications. Floating-point numbers are written with an optional minus sign
followed by a non-empty sequence of digits punctuated at some point with a
decimal point (`.') and/or followed by a scientific-notation marker (the letter
`E' or `e' followed by an optional sign and one or more digits). Here are some
examples of floating-point numbers:

325.0 325. 3.25e2 0.325E3 325.E1 .0325e+4 32500e-2

All of these examples mean the same number. The third of these, as an example
of scientific notation, should be read "3.25 times 10 to the power of 2".

Fine points: The MOO represents floating-point numbers using the local
meaning of the C-language double type, which is almost always equivalent
to IEEE 754 double precision floating point. If so, then the smallest positive
floating-point number is no larger than 2.2250738585072014e-308 and the
largest floating-point number is 1.7976931348623157e+308.

IEEE infinities and NaN values are not allowed in MOO. The error
E_FLOAT is raised whenever an infinity would otherwise be computed;
E_INVARG is raised whenever a NaN would otherwise arise. The value
0.0 is always returned on underflow.

Character strings are arbitrarily-long sequences of normal, ASCII
printing characters. When written as values in a program, strings are
enclosed in double-quotes, like this:

"This is a character string."

To include a double-quote in the string, precede it with a backslash
(`\'), like this:

"His name was \"Leroy\", but nobody ever called him that."

Finally, to include a backslash in a string, double it:

"Some people use backslash ('\\') to mean set difference."

MOO strings may not include special ASCII characters like carriage-return,
line-feed, bell, etc. The only non-printing characters allowed are spaces and
tabs.

Fine point: There is a special kind of string used for representing the
arbitrary bytes used in general, binary input and output. In a binary
string, any byte that isn't an ASCII printing character or the space character
is represented as the three-character substring "~XX", where XX is the
hexadecimal representation of the byte; the input character `~' is represented
by the three-character substring "~7E". This special representation is used by
the functions encode_binary() and decode_binary() and by the
functions notify() and read() with network connections that are
in binary mode. See the descriptions of the set_connection_option(),
encode_binary(), and decode_binary() functions for more details.

Objects are the backbone of the MOO database and, as such, deserve a
great deal of discussion; the entire next section is devoted to them. For now,
let it suffice to say that every object has a number, unique to that object.
In programs, we write a reference to a particular object by putting a hash mark
(`#') followed by the number, like this:

#495

Object numbers are always integers.

There are three special object numbers used for a variety of purposes:
#-1, #-2, and #-3, usually referred to in the
LambdaCore database as $nothing, $ambiguous_match, and
$failed_match, respectively.

Errors are, by far, the least frequently used values in MOO. In the
normal case, when a program attempts an operation that is erroneous for some
reason (for example, trying to add a number to a character string), the server
stops running the program and prints out an error message. However, it is
possible for a program to stipulate that such errors should not stop execution;
instead, the server should just let the value of the operation be an error
value. The program can then test for such a result and take some appropriate
kind of recovery action. In programs, error values are written as words
beginning with `E_'. The complete list of error values, along with their
associated messages, is as follows:

The final kind of value in MOO programs is lists. A list is a sequence
of arbitrary MOO values, possibly including other lists. In programs,
lists are written in mathematical set notation with each of the elements
written out in order, separated by commas, the whole enclosed in curly
braces (`{' and `}'). For example, a list of the names of
the days of the week is written like this:

Note that it doesn't matter that we put a line-break in the middle of
the list. This is true in general in MOO: anywhere that a space can go,
a line-break can go, with the same meaning. The only exception is
inside character strings, where line-breaks are not allowed.