System Module
-------------
-> Tests for functionality "Intepret Tamsin program"
The module `$` contains a number of built-in productions which would not
be possible or practical to implement in Tamsin. See Appendix C for a list.
In fact, we have been using the `$` module already! But our usage of it
has been hidden under some syntactic sugar. For example, `"k"` is actually...
| main = $:expect(k).
+ k
= k
| main = $:expect(k).
+ l
? expected 'k' but found 'l'
The section about aliases needs to be written too.
Here's `$:alnum`, which only consumes tokens where the first character is
alphanumeric.
| main = "(" & {$:alnum → A} & ")" & A.
+ (abc123deefghi459876jklmnopqRSTUVXYZ0)
= 0
| main = "(" & {$:alnum → A} & ")" & A.
+ (abc123deefghi459876!jklmnopqRSTUVXYZ0)
? expected ')' but found '!'
Here's `$:upper`, which only consumes tokens where the first character is
uppercase alphabetic.
| main = "(" & {$:upper → A} & ")" & A.
+ (ABCDEFGHIJKLMNOPQRSTUVWXYZ)
= Z
| main = "(" & {$:upper → A} & ")" & A.
+ (ABCDEFGHIJKLMNoPQRSTUVWXYZ)
? expected ')' but found 'o'
Here's `$:startswith`, which only consumes tokens which start with
the given term. (For a single-character scanner this isn't very
impressive.)
| main = "(" & {$:startswith('A') → A} & ")" & A.
+ (AAAA)
= A
| main = "(" & {$:startswith('A') → A} & ")" & A.
+ (AAAABAAA)
? expected ')' but found 'B'
Here's `$:mkterm`, which takes an atom and a list and creates a constructor.
| main = $:mkterm(atom, list(a, list(b, list(c, nil)))).
= atom(a, b, c)
Here's `$:unquote`, which takes three terms, X, L and R, where L and R
must be atoms. If X begins with L and ends with R then the contents
in-between will be returned as an atom. Otherwise fails.
| main = $:unquote('"hello"', '"', '"').
= hello
| main = $:unquote('(hello)', '(', ')').
= hello
| main = $:unquote('(hello)', '(', '"').
? term '(hello)' is not quoted with '(' and '"'
| main = $:unquote('(hello)', '[', ')').
? term '(hello)' is not quoted with '[' and ')'
The quotes can be Unicode characters.
| main = $:unquote('“hello”', '“', '”').
= hello
The quotes can be multiple characters.
| main = $:unquote('%-hello-%', '%-', '-%').
= hello
The quotes can even be empty strings.
| main = $:unquote('hello', '', '').
= hello
Here's `$:equal`, which takes two terms, L and R. If L and R are equal,
succeeds and returns that term which they both are. Otherwise fails.
Two atoms are equal if their texts are identical.
| main = $:equal('hi', 'hi').
= hi
| main = $:equal('hi', 'lo').
? term 'hi' does not equal 'lo'
Two constructors are equal if their texts are identical, they have the
same number of subterms, and all of their corresponding subterms are equal.
| main = $:equal(hi(there), hi(there)).
= hi(there)
| main = $:equal(hi(there), lo(there)).
? term 'hi(there)' does not equal 'lo(there)'
| main = $:equal(hi(there), hi(here)).
? term 'hi(there)' does not equal 'hi(here)'
| main = $:equal(hi(there), hi(there, there)).
? term 'hi(there)' does not equal 'hi(there, there)'
Here's `$:emit`, which takes an atom and outputs it. Unlike `print`, which
is meant for debugging, `$:emit` does not append a newline, and is 8-bit-clean.
| main = $:emit('`') & $:emit('wo') & ''.
= `wo
-> Tests for functionality "Intepret Tamsin program (pre- & post-processed)"
`$:emit` is 8-bit-clean: if the atom contains unprintable characters,
`$:emit` does not try to make them readable by UTF-8 or any other encoding.
(`print` may or may not do this, depending on the implementation.)
| main = $:emit('\x00\x01\x02\xfd\xfe\xff') & ''.
= 000102fdfeff0a
-> Tests for functionality "Intepret Tamsin program"
Here's `$:repr`, which takes a term and results in an atom which is the
result of reprifying that term (see section on Terms, above.)
| main = $:repr(hello).
= hello
| main = $:repr('016fo_oZZ').
= 016fo_oZZ
| main = $:repr('016fo$oZZ').
= '016fo$oZZ'
| main = $:repr('').
= ''
| main = $:repr(' ').
= ' '
| main = $:repr('016\n016').
= '016\x0a016'
| main = $:repr(hello(there, world)).
= hello(there, world)
| main = V ← '♡' & $:repr('□'(there, V)).
= '\xe2\x96\xa1'(there, '\xe2\x99\xa1')
| main = $:repr(a(b(c('qu\'are\\')))).
= a(b(c('qu\'are\\')))
| main = $:repr('\x99').
= '\x99'
Here's `$:reverse`, which takes a term E, and a term of the form
`X(a, X(b, ... X(z, E)) ... )`, and returns a term of the form
`X(z, X(y, ... X(a, E)) ... )`. The constructor tag X is often `cons`
or `pair` or `list` and E is often `nil`.
| main = $:reverse(list(a, list(b, list(c, nil))), nil).
= list(c, list(b, list(a, nil)))
E need not be an atom.
| main = $:reverse(list(a, list(b, list(c, hello(world)))), hello(world)).
= list(c, list(b, list(a, hello(world))))
If the tail of the list isn't E, an error occurs.
| main = $:reverse(list(a, list(b, list(c, hello(world)))), nil).
? malformed list
If some list constructor doesn't have two children, an error occurs.
| main = $:reverse(list(a, list(b, list(nil))), nil).
? malformed list
The constructor tag can be anything.
| main = $:reverse(foo(a, foo(b, foo(c, nil))), nil).
= foo(c, foo(b, foo(a, nil)))
But if there is a different constructor somewhere in the list, well,
| main = $:reverse(foo(a, fooz(b, foo(c, nil))), nil).
? malformed list
You can reverse an empty list.
| main = $:reverse(nil, nil).
= nil
But of course,
| main = $:reverse(nil, zilch).
? malformed list
This is a shallow reverse. Embedded lists are not reversed.
| main = $:reverse(list(a, list(list(1, list(2, nil)), list(c, nil))), nil).
= list(c, list(list(1, list(2, nil)), list(a, nil)))
Here's `$:gensym`.
| main = $:gensym('foo').
= foo1
| main = $:gensym('foo') → F & $:gensym('foo') → G & $:equal(F, G).
? 'foo1' does not equal 'foo2'
Here's `$:hexbyte`.
| main = $:hexbyte('5', '0').
= P
| main = $:hexbyte('f', 'f') → C & $:repr(C).
= '\xff'
Here's `$:format_octal`, which makes me feel ill.
| main = $:format_octal('P').
= 120
| main = $:format_octal('\xff').
= 377
There are never any leading zeroes.
| main = $:format_octal('\n').
= 12
It works on the first byte of the string only.
| main = $:format_octal('«').
= 302
Here's `$:length`, which returns an atom representing the length, in bytes,
of the given term (flattened.) Note that this is an atom, not an integer,
because Tamsin doesn't even have integers.
| main = $:length(abcde).
= 5
| main = $:length('').
= 0
| main = $:length('♥').
= 3
| main = $:length(a( b , c )).
= 7