Data types - Part II
This is a quick overview of the composite data types in Motto.
The data stack
Any value typed at the REPL is automatically pushed to the stack. Here are some basic stack operations:
> 10 20 30 10 20 30 > .p ;; Pop the stack 10 20 > .c ;; Clear the stack > 100 20 78 32 12 [*] reduce 59904000 > .c > ;; Find the mean of all numbers on the stack: > 6 11 7 length len @ [+] reduce len / 8 > red green blue > ;; Check if the stack contains a particular value: > red contains #t > [display newline] println @ > ;; The stack can be used as a key-value store: > name: sam age: 20 > name: get println sam > age: get println 20
The stack does away with the need to pass arguments explicitly to procedures. Procedures can leave any number of results on the stack. As an example, let us define a procedure for computing the mean of a list of numbers:
> [length count @ [+] reduce-intact count quotient] mean @ > 6 7 11 mean println 8 > .c > 10 20 30 40 50 60 mean println 35
Mean is one of many averages that can be derived from a sequence of numbers.
We can also define procedures to compute other averages like median, mode and range.
There can be a single procedure that is used to aggregate all these averages together:
> [[gt] sort length len @ len 2 quotient mid @ len is-odd ? [mid at] [mid at mid at + 2 quotient]] median @ > [most-occurs] mode @ > [[max] reduce-intact mx @ [min] reduce-intact mn @ mx mn -] range @ > [median avg_median @ mean avg_mean @ mode avg_mode @ range avg_range @ .c median: avg_median mean: avg_mean mode: avg_mode range: avg_range] averages @ > ;; tests > 1 2 4 4 5 8 9 averages median: 4 mean: 4 mode: 4 range: 8 > .c > 80 100 62 180 21 55 averages median: 71 mean: 83 mode: 21 range: 159 > .c
Each average could be retrieved separately using get:
> 3 5 12 averages > median: get 5 > mean: get 6 > range: get 9 > mode: get 3 > .c
fetch is similar to get, but after retrieving the value, it removes
the mapping from the stack. In the last post
we saw how to use get to implement a procedure that take keyword arguments.
Here we will redefine that procedure to use fetch so that the arguments are
actually consumed by the procedure. In fact, having an extended form of fetch
that can return a default value will be more useful here:
> ;; Extended form of `fetch` that accepts a default value. > [key @ default @ key fetch dup key eq default swap if] fetch-d @ > ;; Procedure to compute distance between two points. If an argument is not ;; specified, it will default to 0. > [0 x2: fetch-d 0 x1: fetch-d - 2 expt 0 y2: fetch-d 0 y1: fetch-d - 2 expt + sqrt] distance @ > x1: 10 x2: 5 y1: 100 y2: 120 distance 20.615528128088304 > .c > x1: 10 x2: 5 distance 5
Pair and List
As the name suggests pair is a composite of two values.
> 10 20 pair (10 . 20) > dup first (10 . 20) 10 > swap second 10 20
It is possible to construct a list by making a pair point to another:
> 10 20 30 40 50 [pair] reduce (10 20 30 40 . 50)
Motto has a built-in list type. The values on the stack can be wrapped up in a new
list using the list procedure:
> 10 20 30 40 50 list lst @ > lst (10 20 30 40 50) > list-length 5 > .c > lst list-first lst list-rest 10 (20 30 40 50) > .c > lst list-reverse (50 40 30 20 10) > hello lst list-push (hello 10 20 30 40 50) > hello lst list-append (10 20 30 40 50 hello) > [2 * display #\space display] lst list-for-each 20 40 60 80 100 > .c > ;; The `map` function from Lisp: > [list-for-each list] my-list-map @ > [2 *] lst my-list-map (20 40 60 80 100)
Array
Arrays are more efficient than lists for some operations, especially for accessing
an arbitrary element. There are two ways to create an array. Either by using the array
procedure or by typing in an array literal:
> a b c d array #(a b c d) > ; An array literal. > #(1 2 3 4 5) #(1 2 3 4 5) > a b c d array arr @ > 0 arr array-at a > hello 0 arr array-set #(hello b c d) > arr ; array-set modifies the array. #(hello b c d) > #(1 2 3 4) #(hello world) array-concat #(1 2 3 4 hello world) > array-length 6
String
Strings are sequences of characters.
> "hello, world" s @
> 1 s string-at
#\e
> 3 5 s substring "lo" string-eq
#t
> 3 5 s substring "LO" string-eq ; `string-eq` is case-sensitive.
#f
> 3 5 s substring "LO" string-ci-eq
#t
> ; split the string using comma as the delimiter.
> #\, s string-split
("hello" " world")
> ; use space as the delimiter.
> #\space s string-split
("hello," "world")
> ; search for a substring.
> "hello" s string-find
0
> "hullo" s string-find
#f
> "hEllo" s string-find
#f
> "hEllo" s string-ci-find
0
> "llo" s string-find
2
> "hello " "world" string-append
"worldhello "
> "hello " "world" string-concat
"hello world"Map
Map is a data structure that acts like a dictionary, where a value is associated
with a key. symbols and keywords are the most natural candidates for keys.
> name: mat age: 45 map m @ > name: m map-at mat > ; `map-at` will raise an error if the key is not found. > salary: m map-at #<$error #3 tag: value-not-found message: "Value not found."> > .c > ; `map-get` allows to pass a default value for a missing key. > 1450 salary: m map-get 1450 > salary: 5000 m map-put > 1450 salary: m map-at 5000
A map can stand-in for the switch-case control structure found in many imperative
languages:
> [signal @ red [stop! .s .c] green [go! .s .c] yellow [be ready .s .c] map signals @ ["not a valid signal" error .s .c] signal signals map-get !] signal-action @ > red signal-action stop! > yellow signal-action be ready > green signal-action go! > black signal-action #<$error #2 tag: error message: "not a valid signal"> > red signal-action stop!
