| 921 | 921 |
| string = $:alnum/''.
|
| 922 | 922 |
+ *hi*there*nice*day*isnt*it
|
| 923 | 923 |
= cons(it, cons(isnt, cons(day, cons(nice, cons(there, cons(hi, nil))))))
|
|
924 |
|
|
925 |
### System Module ###
|
|
926 |
|
|
927 |
The module `$` contains a number of built-in productions which would not
|
|
928 |
be possible or practical to implement in Tamsin. See Appendix C for a list.
|
|
929 |
|
|
930 |
In fact, we have been using the `$` module already! But our usage of it
|
|
931 |
has been hidden under some syntactic sugar. The following examples are
|
|
932 |
the same as `main = "k".`
|
|
933 |
|
|
934 |
| main = $:expect(k).
|
|
935 |
+ k
|
|
936 |
= k
|
|
937 |
|
|
938 |
| main = $:expect(k).
|
|
939 |
+ l
|
|
940 |
? expected 'k' found 'l'
|
|
941 |
|
|
942 |
The section about aliases needs to be written too.
|
|
943 |
|
|
944 |
Here's `$:alnum`, which only consumes tokens where the first character is
|
|
945 |
alphanumeric.
|
|
946 |
|
|
947 |
| main = "(" & {$:alnum → A} & ")" & A.
|
|
948 |
+ (abc123deefghi459876jklmnopqRSTUVXYZ0)
|
|
949 |
= 0
|
|
950 |
|
|
951 |
| main = "(" & {$:alnum → A} & ")" & A.
|
|
952 |
+ (abc123deefghi459876!jklmnopqRSTUVXYZ0)
|
|
953 |
? expected ')' found '!'
|
|
954 |
|
|
955 |
Here's `$:upper`, which only consumes tokens where the first character is
|
|
956 |
uppercase alphabetic.
|
|
957 |
|
|
958 |
| main = "(" & {$:upper → A} & ")" & A.
|
|
959 |
+ (ABCDEFGHIJKLMNOPQRSTUVWXYZ)
|
|
960 |
= Z
|
|
961 |
|
|
962 |
| main = "(" & {$:upper → A} & ")" & A.
|
|
963 |
+ (ABCDEFGHIJKLMNoPQRSTUVWXYZ)
|
|
964 |
? expected ')' found 'o'
|
|
965 |
|
|
966 |
Here's `$:startswith`, which only consumes tokens which start with
|
|
967 |
the given term. (For a single-character scanner this isn't very
|
|
968 |
impressive.)
|
|
969 |
|
|
970 |
| main = "(" & {$:startswith('A') → A} & ")" & A.
|
|
971 |
+ (AAAA)
|
|
972 |
= A
|
|
973 |
|
|
974 |
| main = "(" & {$:startswith('A') → A} & ")" & A.
|
|
975 |
+ (AAAABAAA)
|
|
976 |
? expected ')' found 'B'
|
|
977 |
|
|
978 |
Here's `$:mkterm`, which takes an atom and a list and creates a constructor.
|
|
979 |
|
|
980 |
| main = $:mkterm(atom, list(a, list(b, list(c, nil)))).
|
|
981 |
= atom(a, b, c)
|
|
982 |
|
|
983 |
Here's `$:unquote`, which takes three terms, X, L and R, where L and R
|
|
984 |
must be one-character atoms. If X begins with L and ends with R then
|
|
985 |
the contents in-between will be returned as an atom. Otherwise fails.
|
|
986 |
|
|
987 |
| main = $:unquote('"hello"', '"', '"').
|
|
988 |
= hello
|
|
989 |
|
|
990 |
| main = $:unquote('(hello)', '(', ')').
|
|
991 |
= hello
|
|
992 |
|
|
993 |
| main = $:unquote('(hello)', '(', '"').
|
|
994 |
? term '(hello)' is not quoted with '(' and '"'
|
|
995 |
|
|
996 |
Here's `$:equal`, which takes two terms, L and R. If L and R are equal,
|
|
997 |
succeeds and returns that term which they both are. Otherwise fails.
|
|
998 |
|
|
999 |
Two atoms are equal if their texts are identical.
|
|
1000 |
|
|
1001 |
| main = $:equal('hi', 'hi').
|
|
1002 |
= hi
|
|
1003 |
|
|
1004 |
| main = $:equal('hi', 'lo').
|
|
1005 |
? term 'hi' does not equal 'lo'
|
|
1006 |
|
|
1007 |
Two constructors are equal if their texts are identical, they have the
|
|
1008 |
same number of subterms, and all of their corresponding subterms are equal.
|
|
1009 |
|
|
1010 |
| main = $:equal(hi(there), hi(there)).
|
|
1011 |
= hi(there)
|
|
1012 |
|
|
1013 |
| main = $:equal(hi(there), lo(there)).
|
|
1014 |
? term 'hi(there)' does not equal 'lo(there)'
|
|
1015 |
|
|
1016 |
| main = $:equal(hi(there), hi(here)).
|
|
1017 |
? term 'hi(there)' does not equal 'hi(here)'
|
|
1018 |
|
|
1019 |
| main = $:equal(hi(there), hi(there, there)).
|
|
1020 |
? term 'hi(there)' does not equal 'hi(there, there)'
|
|
1021 |
|
|
1022 |
........................................................
|
|
1023 |
|
|
1024 |
Here's `$:reverse`, which takes a term E, and a term of the form
|
|
1025 |
`X(a, X(b, ... X(z, E)) ... )`, and returns a term of the form
|
|
1026 |
`X(z, X(y, ... X(a, E)) ... )`. The constructor tag X is often `cons`
|
|
1027 |
or `pair` or `list` and E is often `nil`.
|
|
1028 |
|
|
1029 |
| main = $:reverse(list(a, list(b, list(c, nil))), nil).
|
|
1030 |
= list(c, list(b, list(a, nil)))
|
|
1031 |
|
|
1032 |
E need not be an atom.
|
|
1033 |
|
|
1034 |
| main = $:reverse(list(a, list(b, list(c, hello(world)))), hello(world)).
|
|
1035 |
= list(c, list(b, list(a, hello(world))))
|
|
1036 |
|
|
1037 |
If the tail of the list isn't E, an error occurs.
|
|
1038 |
|
|
1039 |
| main = $:reverse(list(a, list(b, list(c, hello(world)))), nil).
|
|
1040 |
? malformed list
|
|
1041 |
|
|
1042 |
If some list constructor doesn't have two children, an error occurs.
|
|
1043 |
|
|
1044 |
| main = $:reverse(list(a, list(b, list(nil))), nil).
|
|
1045 |
? malformed list
|
|
1046 |
|
|
1047 |
The constructor tag can be anything.
|
|
1048 |
|
|
1049 |
| main = $:reverse(foo(a, foo(b, foo(c, nil))), nil).
|
|
1050 |
= foo(c, foo(b, foo(a, nil)))
|
|
1051 |
|
|
1052 |
But if there is a different constructor somewhere in the list, well,
|
|
1053 |
|
|
1054 |
| main = $:reverse(foo(a, fooz(b, foo(c, nil))), nil).
|
|
1055 |
? malformed list
|
|
1056 |
|
|
1057 |
You can reverse an empty list.
|
|
1058 |
|
|
1059 |
| main = $:reverse(nil, nil).
|
|
1060 |
= nil
|
|
1061 |
|
|
1062 |
But of course,
|
|
1063 |
|
|
1064 |
| main = $:reverse(nil, zilch).
|
|
1065 |
? malformed list
|
|
1066 |
|
|
1067 |
This is a shallow reverse. Embedded lists are not reversed.
|
|
1068 |
|
|
1069 |
| main = $:reverse(list(a, list(list(1, list(2, nil)), list(c, nil))), nil).
|
|
1070 |
= list(c, list(list(1, list(2, nil)), list(a, nil)))
|