Data Types

things you can store and manipulate

Variables in MiniScript are dynamically typed; you can store any type of data in any variable. But what types of data are there? In MiniScript, there are four primary data types: numbers, strings, lists, and maps. There are a couple of other more obscure types, such as function and null. Everything else, including classes and objects, is actually a special case of a map.

Numbers

All numeric values in MiniScript are stored in standard full-precision format (also known as “doubles” in C-derived languages). Numbers are also used to represent true (1) and false (0).

Numeric literals are written as ordinary numbers, e.g. 42, 3.1415, -0.24.

You can use the following operators on numbers (where a and b are numbers).

Note that and, or, and not are not functions; they are operators, and go between (or in the case of not, before) their operands just like all the others.

You can check whether a variable contains a number with the isa operator. There is an intrinsic class called number, and x isa number returns true (1) whenever x is, in fact, a number.

Strings

Text values in MiniScript are stored as strings of Unicode characters. String literals in the code are enclosed by double quotes ("). Be sure to use ordinary straight quotes, not the fancy curly quotes some word processors insist on making.

If your string literal needs to include quotation marks, you can do this by typing the quotation marks twice. For example:

s = "If you do not help us, we shall say ""Ni"" to you."

Strings may be concatenated with the + operator, and if you try to add a number and a string together, the number will be automatically converted to a string and then concatenated. Strings may also be replicated (repeated) or cut down to a fraction of their former selves, by
multiplying or dividing them by a number.

s = "Spam" * 5 // SpamSpamSpamSpamSpam
s = s / 2 // SpamSpamSp

The full set of string operators is shown below; s and t are strings, and n and m are numbers.

The table above does not include and, or, and not, but these operators work perfectly well on strings through boolean coercion (see „The Nature of Truth“ in the previous chapter). In any boolean context, s is considered true if it contains any characters, and false if it is the empty string.

Also not listed is behavior of the isa operator with strings. There is an intrinsic type called string, and s isa string returns true (1) for any string s.

The slice operators deserve a bit of explanation. The basic syntax is s[n:m], which gets a substring of s starting at character n, and going up to (but not including) character m, where we number characters starting from 0. But this basic syntax is extended with a handful of neat tricks:

1. You may specify just a single index, leaving out the colon, to get a single character. Thus s[0] is the first character, s[1] is the second, etc.
2. You may use a negative index, and it will count from the end. So s[-1] is the last character, s[-2] is the next-to-last, etc. This works for any of the slice indexes.
3. You may omit the first index from the two-index form, and it will default to 0. This is a handy way to get the first n characters of a string. So s[:3] returns the first 3 characters of s; s[:-3] returns all but the last three characters of s.
4. You may omit the last index from the two-index form, and it will continue to the end of the string. Thus, s[3:] skips the first three characters and returns the rest of the string.

The way these indexes work results in a lot of very handy properties. For example, s[:n] + s[n:] == s for any value of n from 0 through s.len; in other words, there is a very natural syntax for splitting a string into two parts, which is a fairly common thing to do.

Finally, note that strings are immutable; just like numbers, you can never change a string, but you can create a new string and assign it to an existing variable. The following example shows one correct and one incorrect way to change “spin” into “spun”.

s = "spin"
s = s[:2] + "u" + s[3:] // OK
s[3] = "u" // no can do (Runtime Error)

Lists

The third basic data type in MiniScript is the list. This is an ordered collection of elements, accessible by index starting with zero. Each element of a list may be any type, including another list.

You define a list by using square brackets around the elements, which should be separated with commas.

x = [2, 4, 6, 8]

The code above creates a list with four elements and assigns it to x. But again, list elements don’t have to be numbers; they can also be strings, lists, or maps. Here’s another example.

x = [2, "four", [1, 2, 3], {8:"eight"}]

Working with a list is very much like working with a string. You can concatenate two lists with +, replicate or cut a list with * and /, and access elements or sublists using the same slice syntax. Here are the operators valid on lists, where p and q are lists, and n and m are numbers.

In addition, you can use x isa list to check whether any variable x contains a list.

The slice operators work exactly the same way as with strings. So p[-1] is the last element of list p; p[3:] skips the first three elements and returns the rest of the list, and so forth.

However, there is one important difference: lists are mutable. You can change the contents of a list, by assigning to any of the slice expressions, and no matter how many different variables are referring to that list, they will all see the change. The following example illustrates.

a = [1, 2, 3] // creates a list and assigns to a
b = a // assigns that SAME list to b
a[-1] = 5 // changes the last element of our list to 5
print(b) // prints: [1, 2, 5]

Because a and b both refer to the same list, any changes (mutations) made to that list can be seen from either variable.

If you want to be sure you have a fresh copy of a list, rather than a shared reference, a common trick is to use [0:] to make a slice that includes the entire list. This copies the elements into a new list. Compare the following example to the previous one.

a = [1, 2, 3] // creates a list and assigns to a
b = a[0:] // assigns a COPY of that list to b
a[-1] = 5 // changes the last element of our first list to 5
print(b) // prints: [1, 2, 3] (our copy hasn't changed)

Maps

The final basic data type in MiniScript is the map. A map is a set of key-value pairs, where each unique key maps to some value. In some programming environments, this same concept is called a dictionary.

Create a map with curly braces around a comma-separated list of key-value pairs. Specify each pair by separating the key and value with a colon, as shown here.

m = {1:"one", 2:"two", 3:"three"}

The map created here contains three key-value pairs, each mapping a number to a string (which happens to be the English word for that number in this example).

Map keys may be numbers or strings, and must be unique; if you reuse a key, the previous value is replaced. Values may be any type, including lists or dictionaries. Order within a map is not preserved; for loops iterate over a map in arbitrary order.

Maps support only a handful of operators (d and e are maps, k is a key, and v is a value):

There are two ways to get and set members of a map. The first is to use the square-brackets index operator, just as with strings or lists, except that in the case of a map, the key can be a string as well as a number.

d = {"yes":"hai", "no":"iie", "maybe":"tabun"}
print(d["maybe"]) // prints: tabun
d["maybe"] = "kamo"
print(d["maybe"]) // prints: kamo

The second way is using the dot indexer. This works only in the special case where the key is a string that is a valid identifier: it begins with a letter, and contains only letters, numbers, and underscores. In this case you can write the key after a dot rather than enclosing it in square brackets and quotation marks — the key essentially becomes an identifier in the language. The following is functionally equivalent to the previous example.

d = {"yes":"hai", "no":"iie", "maybe":"tabun"}
print(d.maybe) // prints: tabun
d["maybe"] = "kamo"
print(d.maybe) // prints: kamo 

This dot indexer is mostly syntactic sugar that makes accessing elements of a map easier to read and write. But there are some subtle differences in cases where the map represents a class or object, as described in the next chapter.

Finally, like the other basic types, there is an intrinsic class that represents maps — map in this case. So x isa map will return true for any map (including any class or object, as you’ll see in the next section).

Type Checking

The isa operator was mentioned several times above. This is how you can check, at runtime, what sort of data you have. In many cases you won’t care, thanks to MiniScripts automatic type conversion. But sometimes you do.

Suppose for example you want to make a method that prints its argument surrounded by
parentheses… but if the caller passes in a list, then you want to join the elements of that list with commas. You could accomplish that with isa.

spew = function(x)
if x isa list then x = x.join(", ")
print "(" + x + ")"
end function
spew 42 // prints: (42)
spew [18, 42, "hike!"] // prints: (18, 42, hike!)

Extending Built-In Types

The four built-in types — number, string, list, and map — are just ordinary maps, like your own classes (which you’ll learn about next, I promise). You can add new methods to them, and then invoke those methods using dot syntax on ordinary numbers, strings, lists, and maps. (The only limitation is that you can’t use dot syntax with a numeric literal.) If this sounds like Greek to you, don’t worry — it’s an advanced feature, and one most users will never need.