Prev Up Next

The simple data types of Scheme include booleans, numbers, characters, and symbols.

### 2.1.1  Booleans

Scheme's booleans are `#t` for true and `#f` for false. Scheme has a predicate procedure called `boolean?` that checks if its argument is boolean.

```(boolean? #t)              => #t
(boolean? "Hello, World!") => #f
```

The procedure `not` negates its argument, considered as a boolean.

```(not #f)              => #t
(not #t)              => #f
(not "Hello, World!") => #f
```

The last expression illustrates a Scheme convenience: In a context that requires a boolean, Scheme will treat any value that is not `#f` as a true value.

### 2.1.2  Numbers

Scheme numbers can be integers (eg, `42`), rationals (`22/7`), reals (`3.1416`), or complex (`2+3i`). An integer is a rational is a real is a complex number is a number. Predicates exist for testing the various kinds of numberness:

```(number? 42)       => #t
(number? #t)       => #f
(complex? 2+3i)    => #t
(real? 2+3i)       => #f
(real? 3.1416)     => #t
(real? 42)         => #t
(rational? 3.1416) => #f
(rational? 22/7)   => #t
(integer? 22/7)    => #f
(integer? 42)      => #t
```

Scheme integers need not be specified in decimal (base 10) format. They can be specified in binary by prefixing the numeral with `#b`. Thus `#b1100` is the number twelve. The octal prefix is `#o` and the hex prefix is `#x`. (The optional decimal prefix is `#d`.)

Numbers can tested for equality using the general-purpose equality predicate `eqv?`.

```(eqv? 42 42)   => #t
(eqv? 42 #f)   => #f
(eqv? 42 42.0) => #f
```

However, if you know that the arguments to be compared are numbers, the special number-equality predicate `=` is more apt.

```(= 42 42)   => #t
(= 42 #f)   -->ERROR!!!
(= 42 42.0) => #t
```

Other number comparisons are also possible:

```(< 3 2)    => #f
(>= 4.5 3) => #t
```

Arithmetic procedures `+`, `-`, `*`, `/` have the expected behavior:

```(+ 1 2 3) => 6
(- 5.3 2) => 3.3
(- 5 2 1) => 2
(* 1 2 3) => 6
(/  2 3) => 1
```

This is just the tip of the iceberg. Scheme provides a large and comprehensive suite of arithmetic and trigonometric procedures. Consult R5RS KCR98.

### 2.1.3  Characters

Scheme character data are represented by prefixing the character with `#\`. Thus, `#\c` is the character `c`. Some non-graphic characters have more descriptive names, eg, `#\newline`, `#\tab`. The character for space can be written `#\ ` , or more readably, `#\space`.

The character predicate is `char?`:

```(char? #\c) => #t
(char? 1)   => #f
(char? #\;) => #t
```

Note that a semicolon character datum does not trigger a comment.

The character data type has its set of comparison predicates:

```(char=? #\a #\a)  => #t
(char<? #\a #\b)  => #t
(char>=? #\a #\b) #\A
```

### 2.1.4  Symbols

The simple data types we saw above are self-evaluating. Ie, if you typed any object from these data types to the listener, the evaluated result returned by the listener will be the same as what you typed in.

```#t  => #t
42  => 42
#\c => #\c
```

Symbols don't behave the same way. This is because symbols are used by Scheme programs as identifiers for variables, and thus will evaluate to the value that the variable holds. Nevertheless, symbols are a simple data type, and symbols are legitimate values that Scheme can traffic in, along with characters, numbers, and the rest.

To specify a symbol without making Scheme think it is a variable, you should quote the symbol:

```(quote xyz)
=> xyz
```

Since this type of quoting is very common in Scheme, a convenient abbreviation is provided. The expression

```'E
```

will be treated by Scheme as equivalent to

```(quote E)
```

Scheme symbols are named by a sequence of characters. About the only limitation on a symbol's name are that it shouldn't be mistakable for some other data, eg, characters or booleans or numbers or compound data. Thus, `this-is-a-symbol`, `i18n`, `<=>`, and `\$!#*` are all symbols; `16`, `-i` (a complex number!), `#t`, `"this-is-a-string"`, and `(barf)` (a list) are not. The predicate for checking symbolness is called `symbol?`:

```(symbol? 'xyz) => #t
(symbol? 42)   => #f
```

Scheme symbols are normally case-insensitive. Thus the symbols `Calorie` and `calorie` are identical:

```(eqv? 'Calorie 'calorie)
=> #t
```

We can use the symbol `xyz` as a global variable by using the form `define`:

```(define xyz 9)
```

This says the variable `xyz` holds the value `9`. If we feed xyz to the listener, the result will be the value held by `xyz`:

```xyz
=> 9
```

We can use the form `set!` to change the value held by a variable:

```(set! xyz #\c)
```

Now

```xyz
=> #\c
```

Log in or register to write something here or to contact authors.