Commit: 4b3a1764418e682332f903c5d4797fa370476a47 - turbolisp (git)

A small standalone Lisp used as a scripting language in the Z2 game engine

Commit MetaInfo

• Revision: 4b3a1764418e682332f903c5d4797fa370476a47 (tree)
• Time: 2019-11-10 05:10:50
• Author: AlaskanEmily <emily@alas...>
• Commiter: AlaskanEmily

Log Message

Fix line endings

Change Summary

• modified: turbo_s.m
• modified: turbo_s.parser.m
• modified: turbo_s.string_stream.m
• modified: turbolisp.m
• modified: turbolisp.runtime.builtin.arithmetic.m
• modified: turbolisp.runtime.builtin.comparison.m
• modified: turbolisp.runtime.builtin.m
• modified: turbolisp.runtime.m

Incremental Difference

--- a/turbo_s.m
+++ b/turbo_s.m
@@ -1,87 +1,87 @@
-% Any copyright is dedicated to the Public Domain.
-% http://creativecommons.org/publicdomain/zero/1.0/
-
-:- module turbo_s.
-
-%=============================================================================%
-% S-expression parser for TurboLisp
-:- interface.
-%=============================================================================%
-
-:- use_module io.
-:- import_module list.
-:- use_module maybe.
-
-:- include_module turbo_s.parser.
-:- include_module turbo_s.string_stream.
-
-:- use_module turbo_s.string_stream.
-
-%-----------------------------------------------------------------------------%
-
-:- type element ---> atom(string) ; list(list.list(element)).
-
-%-----------------------------------------------------------------------------%
-
-:- pred parse(io.text_input_stream, list.list(element), io.res(list.list(element)), io.io, io.io).
-:- mode parse(in, in, out, di, uo) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred parse_string_stream(string,
-    list.list(element),
-    turbo_s.string_stream.string_range,
-    maybe.maybe_error(list.list(element))).
-:- mode parse_string_stream(in, in, di, out) is det.
-
-%=============================================================================%
-:- implementation.
-%=============================================================================%
-
-:- use_module stream.
-
-:- use_module turbo_s.parser.
-
-%-----------------------------------------------------------------------------%
-
-:- func ss_errors = turbo_s.parser.errors(turbo_s.string_stream.error).
-ss_errors = turbo_s.parser.errors(
-    turbo_s.string_stream.error("Unexpected EOF"),
-    turbo_s.string_stream.error("Unmatched close paren")).
-
-%-----------------------------------------------------------------------------%
-
-parse_string_stream(String, List, StringRangeIn, Result) :-
-    turbo_s.parser.parse(String, ss_errors, ElementResult, StringRangeIn, StringRangeOut),
-    (
-        ElementResult = stream.ok(Element),
-        parse_string_stream(String, [Element|List], StringRangeOut, Result)
-    ;
-        ElementResult = stream.eof,
-        Result = maybe.ok(list.reverse(List))
-    ;
-        ElementResult = stream.error(turbo_s.string_stream.error(E)),
-        Result = maybe.error(E)
-    ).
-
-%-----------------------------------------------------------------------------%
-
-:- func io_errors = turbo_s.parser.errors(io.error).
-io_errors = turbo_s.parser.errors(
-    io.make_io_error("Unexpected EOF"),
-    io.make_io_error("Unmatched close paren")).
-
-%-----------------------------------------------------------------------------%
-
-parse(Stream, List, Result, !IO) :-
-    turbo_s.parser.parse(Stream, io_errors, ElementResult, !IO),
-    (
-        ElementResult = stream.ok(Element),
-        parse(Stream, [Element|List], Result, !IO)
-    ;
-        ElementResult = stream.eof,
-        Result = io.ok(list.reverse(List))
-    ;
-        ElementResult = stream.error(E),
-        Result = io.error(E)
+% Any copyright is dedicated to the Public Domain.
+% http://creativecommons.org/publicdomain/zero/1.0/
+
+:- module turbo_s.
+
+%=============================================================================%
+% S-expression parser for TurboLisp
+:- interface.
+%=============================================================================%
+
+:- use_module io.
+:- import_module list.
+:- use_module maybe.
+
+:- include_module turbo_s.parser.
+:- include_module turbo_s.string_stream.
+
+:- use_module turbo_s.string_stream.
+
+%-----------------------------------------------------------------------------%
+
+:- type element ---> atom(string) ; list(list.list(element)).
+
+%-----------------------------------------------------------------------------%
+
+:- pred parse(io.text_input_stream, list.list(element), io.res(list.list(element)), io.io, io.io).
+:- mode parse(in, in, out, di, uo) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred parse_string_stream(string,
+    list.list(element),
+    turbo_s.string_stream.string_range,
+    maybe.maybe_error(list.list(element))).
+:- mode parse_string_stream(in, in, di, out) is det.
+
+%=============================================================================%
+:- implementation.
+%=============================================================================%
+
+:- use_module stream.
+
+:- use_module turbo_s.parser.
+
+%-----------------------------------------------------------------------------%
+
+:- func ss_errors = turbo_s.parser.errors(turbo_s.string_stream.error).
+ss_errors = turbo_s.parser.errors(
+    turbo_s.string_stream.error("Unexpected EOF"),
+    turbo_s.string_stream.error("Unmatched close paren")).
+
+%-----------------------------------------------------------------------------%
+
+parse_string_stream(String, List, StringRangeIn, Result) :-
+    turbo_s.parser.parse(String, ss_errors, ElementResult, StringRangeIn, StringRangeOut),
+    (
+        ElementResult = stream.ok(Element),
+        parse_string_stream(String, [Element|List], StringRangeOut, Result)
+    ;
+        ElementResult = stream.eof,
+        Result = maybe.ok(list.reverse(List))
+    ;
+        ElementResult = stream.error(turbo_s.string_stream.error(E)),
+        Result = maybe.error(E)
+    ).
+
+%-----------------------------------------------------------------------------%
+
+:- func io_errors = turbo_s.parser.errors(io.error).
+io_errors = turbo_s.parser.errors(
+    io.make_io_error("Unexpected EOF"),
+    io.make_io_error("Unmatched close paren")).
+
+%-----------------------------------------------------------------------------%
+
+parse(Stream, List, Result, !IO) :-
+    turbo_s.parser.parse(Stream, io_errors, ElementResult, !IO),
+    (
+        ElementResult = stream.ok(Element),
+        parse(Stream, [Element|List], Result, !IO)
+    ;
+        ElementResult = stream.eof,
+        Result = io.ok(list.reverse(List))
+    ;
+        ElementResult = stream.error(E),
+        Result = io.error(E)
     ).
\ No newline at end of file

--- a/turbolisp.runtime.builtin.arithmetic.m
+++ b/turbolisp.runtime.builtin.arithmetic.m
@@ -1,170 +1,170 @@
-% Copyright (c) 2019  AlaskanEmily, Transnat Games
-%
-% This Source Code Form is subject to the terms of the Mozilla Public
-% License, v. 2.0. If a copy of the MPL was not distributed with this
-% file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-:- module turbolisp.runtime.builtin.arithmetic.
-
-%=============================================================================%
-% TurboLisp implementation details for arithmetic builtins.
-:- interface.
-%=============================================================================%
-
-:- func int_to_float(int::in) = (float::uo) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- func inc(int) = int.
-
-%-----------------------------------------------------------------------------%
-
-:- type math_pred == (pred(number, number, string)).
-:- mode math_pred == (pred(in, in, uo) is det).
-:- inst math_pred == (pred(in, in, uo) is det).
-
-%-----------------------------------------------------------------------------%
-% TODO: Variadic + and *?
-:- pred builtin_plus `with_type` math_pred `with_inst` math_pred.
-:- pred builtin_minus `with_type` math_pred `with_inst` math_pred.
-:- pred builtin_times `with_type` math_pred `with_inst` math_pred.
-:- pred builtin_divide `with_type` math_pred `with_inst` math_pred.
-
-%-----------------------------------------------------------------------------%
-
-:- pred builtin_arithmetic_bind(math_pred, arithmetic, list(element), result).
-:- mode builtin_arithmetic_bind(math_pred, in, in, res_uo) is det.
-
-%=============================================================================%
-% Most of the implementation of the arithmetic submodule is private.
-:- implementation.
-%=============================================================================%
-
-:- use_module int.
-:- import_module float.
-
-%-----------------------------------------------------------------------------%
-
-:- pragma inline(int_to_float/1).
-
-%-----------------------------------------------------------------------------%
-
-int_to_float(I) = ((0.0)+float(I)).
-
-%-----------------------------------------------------------------------------%
-
-inc(I) = int.plus(I, 1).
-
-%-----------------------------------------------------------------------------%
-
-:- func float_plus(float::in, float::in) = (float::uo) is det.
-:- func float_minus(float::in, float::in) = (float::uo) is det.
-:- func float_times(float::in, float::in) = (float::uo) is det.
-:- func float_divide(float::in, float::in) = (float::uo) is det.
-
-float_plus(A, B) = (A+B).
-float_minus(A, B) = (A-B).
-float_times(A, B) = (A*B).
-float_divide(A, B) = (A/B).
-
-%-----------------------------------------------------------------------------%
-
-:- pred two_atoms(element, element, maybe.maybe_error({string, string})).
-:- mode two_atoms(in, in, out(maybe_unique_error)) is det.
-
-two_atoms(list(_), list(_), maybe.error("Args 1 and 2 not atoms")).
-two_atoms(atom(_), list(_), maybe.error("Arg 2 not atom")).
-two_atoms(list(_), atom(_), maybe.error("Arg 1 not atom")).
-two_atoms(atom(A), atom(B), maybe.ok({A, B})).
-
-:- pragma inline(two_atoms/3).
-
-%-----------------------------------------------------------------------------%
-
-:- pred two_atoms(list.list(element), maybe.maybe_error({string, string})).
-:- mode two_atoms(in, out(maybe_unique_error)) is det.
-
-:- pragma inline(two_atoms/2).
-
-two_atoms(Args, Result) :-
-    (
-        Args = [],
-        Result = maybe.error("no values")
-    ;
-        Args = [_|[]],
-        Result = maybe.error("not 2 values (1)")
-    ;
-        Args = [_|[_|[_|_]]],
-        Result = maybe.error(string.append(string.append(
-            "not 2 values (", string.from_int(list.length(Args))),
-            ")"))
-    ;
-        Args = [A|[B|[]]],
-        two_atoms(A, B, Result)
-    ).
-
-%-----------------------------------------------------------------------------%
-
-:- func arithmetic(func(int, int) = int, func(float, float) = float,
-    number, number) = (string).
-:- mode arithmetic(func(in, in) = (out) is det, func(in, in) = (uo) is det,
-    in, in) = (uo) is det.
-
-arithmetic(Func, _, int(A), int(B)) = string.from_int(Func(A, B)).
-arithmetic(_, Func, float(A), float(B)) = string.from_float(Func(A, B)).
-arithmetic(_, Func, int(A), float(B)) = string.from_float(Func(float(A), B)).
-arithmetic(_, Func, float(A), int(B)) = string.from_float(Func(A, float(B))).
-
-%-----------------------------------------------------------------------------%
-
-builtin_plus(ANum, BNum, arithmetic(int.plus, float_plus, ANum, BNum)).
-builtin_minus(ANum, BNum, arithmetic(int.minus, float_minus, ANum, BNum)).
-builtin_times(ANum, BNum, arithmetic(int.times, float_times, ANum, BNum)).
-builtin_divide(ANum, BNum, arithmetic('int__div', float_divide, ANum, BNum)).
-
-%-----------------------------------------------------------------------------%
-% Implementation of arithmetic operators.
-:- pred arithmetic(math_pred,
-    arithmetic, list.list(element), result).
-:- mode arithmetic(math_pred,
-    in, in, res_uo) is det.
-
-:- pragma inline(arithmetic/4).
-
-arithmetic(Pred, Op, Args, Result) :-
-    two_atoms(Args, ArgsResult),
-    (
-        ArgsResult = maybe.error(Error),
-        builtin_op_tag(arithmetic(Op), Tag),
-        Result = maybe.error(func_error(Tag, 2, Error))
-    ;
-        ArgsResult = maybe.ok({AStr, BStr}),
-        ( if
-            number_type(AStr, ANum)
-        then
-            ( if
-                number_type(BStr, BNum)
-            then
-                Pred(ANum, BNum, Out),
-                Result = maybe.ok(atom(Out))
-            else
-                builtin_op_tag(arithmetic(Op), Tag),
-                Result = maybe.error(func_error(
-                    Tag,
-                    2,
-                    string.append(string.append(
-                        "arg 2 not a number (", BStr), ")")))
-            )
-        else
-            builtin_op_tag(arithmetic(Op), Tag),
-            Result = maybe.error(func_error(
-                Tag,
-                2,
-                string.append(string.append(
-                    "arg 1 not a number (", AStr), ")")))
-        )
-    ).
-
-%-----------------------------------------------------------------------------%
-
-builtin_arithmetic_bind(Pred, Op, Args, Out) :- arithmetic(Pred, Op, Args, Out).
+% Copyright (c) 2019  AlaskanEmily, Transnat Games
+%
+% This Source Code Form is subject to the terms of the Mozilla Public
+% License, v. 2.0. If a copy of the MPL was not distributed with this
+% file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+:- module turbolisp.runtime.builtin.arithmetic.
+
+%=============================================================================%
+% TurboLisp implementation details for arithmetic builtins.
+:- interface.
+%=============================================================================%
+
+:- func int_to_float(int::in) = (float::uo) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- func inc(int) = int.
+
+%-----------------------------------------------------------------------------%
+
+:- type math_pred == (pred(number, number, string)).
+:- mode math_pred == (pred(in, in, uo) is det).
+:- inst math_pred == (pred(in, in, uo) is det).
+
+%-----------------------------------------------------------------------------%
+% TODO: Variadic + and *?
+:- pred builtin_plus `with_type` math_pred `with_inst` math_pred.
+:- pred builtin_minus `with_type` math_pred `with_inst` math_pred.
+:- pred builtin_times `with_type` math_pred `with_inst` math_pred.
+:- pred builtin_divide `with_type` math_pred `with_inst` math_pred.
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_arithmetic_bind(math_pred, arithmetic, list(element), result).
+:- mode builtin_arithmetic_bind(math_pred, in, in, res_uo) is det.
+
+%=============================================================================%
+% Most of the implementation of the arithmetic submodule is private.
+:- implementation.
+%=============================================================================%
+
+:- use_module int.
+:- import_module float.
+
+%-----------------------------------------------------------------------------%
+
+:- pragma inline(int_to_float/1).
+
+%-----------------------------------------------------------------------------%
+
+int_to_float(I) = ((0.0)+float(I)).
+
+%-----------------------------------------------------------------------------%
+
+inc(I) = int.plus(I, 1).
+
+%-----------------------------------------------------------------------------%
+
+:- func float_plus(float::in, float::in) = (float::uo) is det.
+:- func float_minus(float::in, float::in) = (float::uo) is det.
+:- func float_times(float::in, float::in) = (float::uo) is det.
+:- func float_divide(float::in, float::in) = (float::uo) is det.
+
+float_plus(A, B) = (A+B).
+float_minus(A, B) = (A-B).
+float_times(A, B) = (A*B).
+float_divide(A, B) = (A/B).
+
+%-----------------------------------------------------------------------------%
+
+:- pred two_atoms(element, element, maybe.maybe_error({string, string})).
+:- mode two_atoms(in, in, out(maybe_unique_error)) is det.
+
+two_atoms(list(_), list(_), maybe.error("Args 1 and 2 not atoms")).
+two_atoms(atom(_), list(_), maybe.error("Arg 2 not atom")).
+two_atoms(list(_), atom(_), maybe.error("Arg 1 not atom")).
+two_atoms(atom(A), atom(B), maybe.ok({A, B})).
+
+:- pragma inline(two_atoms/3).
+
+%-----------------------------------------------------------------------------%
+
+:- pred two_atoms(list.list(element), maybe.maybe_error({string, string})).
+:- mode two_atoms(in, out(maybe_unique_error)) is det.
+
+:- pragma inline(two_atoms/2).
+
+two_atoms(Args, Result) :-
+    (
+        Args = [],
+        Result = maybe.error("no values")
+    ;
+        Args = [_|[]],
+        Result = maybe.error("not 2 values (1)")
+    ;
+        Args = [_|[_|[_|_]]],
+        Result = maybe.error(string.append(string.append(
+            "not 2 values (", string.from_int(list.length(Args))),
+            ")"))
+    ;
+        Args = [A|[B|[]]],
+        two_atoms(A, B, Result)
+    ).
+
+%-----------------------------------------------------------------------------%
+
+:- func arithmetic(func(int, int) = int, func(float, float) = float,
+    number, number) = (string).
+:- mode arithmetic(func(in, in) = (out) is det, func(in, in) = (uo) is det,
+    in, in) = (uo) is det.
+
+arithmetic(Func, _, int(A), int(B)) = string.from_int(Func(A, B)).
+arithmetic(_, Func, float(A), float(B)) = string.from_float(Func(A, B)).
+arithmetic(_, Func, int(A), float(B)) = string.from_float(Func(float(A), B)).
+arithmetic(_, Func, float(A), int(B)) = string.from_float(Func(A, float(B))).
+
+%-----------------------------------------------------------------------------%
+
+builtin_plus(ANum, BNum, arithmetic(int.plus, float_plus, ANum, BNum)).
+builtin_minus(ANum, BNum, arithmetic(int.minus, float_minus, ANum, BNum)).
+builtin_times(ANum, BNum, arithmetic(int.times, float_times, ANum, BNum)).
+builtin_divide(ANum, BNum, arithmetic('int__div', float_divide, ANum, BNum)).
+
+%-----------------------------------------------------------------------------%
+% Implementation of arithmetic operators.
+:- pred arithmetic(math_pred,
+    arithmetic, list.list(element), result).
+:- mode arithmetic(math_pred,
+    in, in, res_uo) is det.
+
+:- pragma inline(arithmetic/4).
+
+arithmetic(Pred, Op, Args, Result) :-
+    two_atoms(Args, ArgsResult),
+    (
+        ArgsResult = maybe.error(Error),
+        builtin_op_tag(arithmetic(Op), Tag),
+        Result = maybe.error(func_error(Tag, 2, Error))
+    ;
+        ArgsResult = maybe.ok({AStr, BStr}),
+        ( if
+            number_type(AStr, ANum)
+        then
+            ( if
+                number_type(BStr, BNum)
+            then
+                Pred(ANum, BNum, Out),
+                Result = maybe.ok(atom(Out))
+            else
+                builtin_op_tag(arithmetic(Op), Tag),
+                Result = maybe.error(func_error(
+                    Tag,
+                    2,
+                    string.append(string.append(
+                        "arg 2 not a number (", BStr), ")")))
+            )
+        else
+            builtin_op_tag(arithmetic(Op), Tag),
+            Result = maybe.error(func_error(
+                Tag,
+                2,
+                string.append(string.append(
+                    "arg 1 not a number (", AStr), ")")))
+        )
+    ).
+
+%-----------------------------------------------------------------------------%
+
+builtin_arithmetic_bind(Pred, Op, Args, Out) :- arithmetic(Pred, Op, Args, Out).

--- a/turbolisp.runtime.builtin.comparison.m
+++ b/turbolisp.runtime.builtin.comparison.m
@@ -1,83 +1,83 @@
-% Copyright (c) 2019  AlaskanEmily, Transnat Games
-%
-% This Source Code Form is subject to the terms of the Mozilla Public
-% License, v. 2.0. If a copy of the MPL was not distributed with this
-% file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-:- module turbolisp.runtime.builtin.comparison.
-
-%=============================================================================%
-% TurboLisp implementation details for comparison builtins.
-:- interface.
-%=============================================================================%
-
-:- func inverse(cmp_result) = cmp_result.
-:- mode inverse(di) = (uo) is det.
-:- mode inverse(in) = (out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred builtin_comparison_bind(cmp_pred, list(element), result, runtime, runtime).
-:- mode builtin_comparison_bind(cmp_pred, in, res_uo, in, out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred atom_compare(string::in, string::in, comparison_result::uo) is det.
-
-%=============================================================================%
-:- implementation.
-%=============================================================================%
-
-:- use_module exception.
-
-%-----------------------------------------------------------------------------%
-
-:- pragma inline(builtin_comparison_bind/5).
-:- pragma inline(inverse/1).
-
-%-----------------------------------------------------------------------------%
-
-inverse(error(Error)) = error(Error).
-inverse(yes) = no.
-inverse(no) = yes.
-
-%-----------------------------------------------------------------------------%
-
-builtin_comparison_bind(Pred, Args, Result, !Runtime) :-
-    ( if
-        Args = [A, B, Y, N]
-    then
-        Pred(A, B, CmpResult),
-        (
-            CmpResult = yes,
-            Result = maybe.ok(Y)
-        ;
-            CmpResult = no,
-            Result = maybe.ok(N)
-        ;
-            CmpResult = error(Error),
-            Result = maybe.error(Error)
-        )
-    else
-        exception.throw(exception.software_error(
-            "Wrong arity in comparison func (builtin_bind is probably broken)"))
-    ).
-
-%-----------------------------------------------------------------------------%
-
-atom_compare(A, B, Cmp) :-
-    ( if
-        number_type(A, ANum),
-        number_type(B, BNum)
-    then
-        ( if
-            as_int(ANum, BNum, AInt, BInt)
-        then
-            builtin.compare(Cmp, AInt, BInt)
-        else
-            promote(ANum, BNum, AFloat, BFloat),
-            builtin.compare(Cmp, AFloat, BFloat)
-        )
-    else
-        builtin.compare(Cmp, A, B)
-    ).
+% Copyright (c) 2019  AlaskanEmily, Transnat Games
+%
+% This Source Code Form is subject to the terms of the Mozilla Public
+% License, v. 2.0. If a copy of the MPL was not distributed with this
+% file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+:- module turbolisp.runtime.builtin.comparison.
+
+%=============================================================================%
+% TurboLisp implementation details for comparison builtins.
+:- interface.
+%=============================================================================%
+
+:- func inverse(cmp_result) = cmp_result.
+:- mode inverse(di) = (uo) is det.
+:- mode inverse(in) = (out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_comparison_bind(cmp_pred, list(element), result, runtime, runtime).
+:- mode builtin_comparison_bind(cmp_pred, in, res_uo, in, out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred atom_compare(string::in, string::in, comparison_result::uo) is det.
+
+%=============================================================================%
+:- implementation.
+%=============================================================================%
+
+:- use_module exception.
+
+%-----------------------------------------------------------------------------%
+
+:- pragma inline(builtin_comparison_bind/5).
+:- pragma inline(inverse/1).
+
+%-----------------------------------------------------------------------------%
+
+inverse(error(Error)) = error(Error).
+inverse(yes) = no.
+inverse(no) = yes.
+
+%-----------------------------------------------------------------------------%
+
+builtin_comparison_bind(Pred, Args, Result, !Runtime) :-
+    ( if
+        Args = [A, B, Y, N]
+    then
+        Pred(A, B, CmpResult),
+        (
+            CmpResult = yes,
+            Result = maybe.ok(Y)
+        ;
+            CmpResult = no,
+            Result = maybe.ok(N)
+        ;
+            CmpResult = error(Error),
+            Result = maybe.error(Error)
+        )
+    else
+        exception.throw(exception.software_error(
+            "Wrong arity in comparison func (builtin_bind is probably broken)"))
+    ).
+
+%-----------------------------------------------------------------------------%
+
+atom_compare(A, B, Cmp) :-
+    ( if
+        number_type(A, ANum),
+        number_type(B, BNum)
+    then
+        ( if
+            as_int(ANum, BNum, AInt, BInt)
+        then
+            builtin.compare(Cmp, AInt, BInt)
+        else
+            promote(ANum, BNum, AFloat, BFloat),
+            builtin.compare(Cmp, AFloat, BFloat)
+        )
+    else
+        builtin.compare(Cmp, A, B)
+    ).

--- a/turbolisp.runtime.builtin.m
+++ b/turbolisp.runtime.builtin.m
@@ -1,443 +1,443 @@
-% Copyright (c) 2019  AlaskanEmily, Transnat Games
-%
-% This Source Code Form is subject to the terms of the Mozilla Public
-% License, v. 2.0. If a copy of the MPL was not distributed with this
-% file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-:- module turbolisp.runtime.builtin.
-
-%=============================================================================%
-% TurboLisp builtins
-:- interface.
-%=============================================================================%
-
-:- use_module enum.
-
-%-----------------------------------------------------------------------------%
-
-:- type arithmetic --->
-    plus ;
-    minus ;
-    times ;
-    divide.
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(arithmetic).
-
-%-----------------------------------------------------------------------------%
-
-:- type logic --->
-    int_and ;
-    int_or ;
-    int_xor.
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(logic).
-
-%-----------------------------------------------------------------------------%
-
-:- type comparison --->
-    eq ;
-    ne ;
-    lt ;
-    gt ;
-    le ;
-    ge.
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(comparison).
-
-%-----------------------------------------------------------------------------%
-
-:- pred comparison_tag(comparison, string).
-:- mode comparison_tag(in, out) is det.
-:- mode comparison_tag(out, in) is semidet.
-:- mode comparison_tag(out, ui) is semidet. % Iffy
-:- mode comparison_tag(in, in) is semidet. % Implied
-
-%-----------------------------------------------------------------------------%
-
-:- type define --->
-    def ;
-    let ;
-    fn.
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(define).
-
-%-----------------------------------------------------------------------------%
-
-:- type builtin_op --->
-    arithmetic(arithmetic) ;
-    logic(logic) ;
-    comparison(comparison) ;
-    define(define).
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(builtin_op).
-
-%-----------------------------------------------------------------------------%
-
-:- pred builtin_op_enum(builtin_op, int).
-:- mode builtin_op_enum(in, out) is det.
-:- mode builtin_op_enum(out, in) is semidet.
-:- mode builtin_op_enum(in, in) is semidet. % Implied
-
-%-----------------------------------------------------------------------------%
-
-:- pred builtin_op_tag(builtin_op, string).
-:- mode builtin_op_tag(in, out) is det.
-:- mode builtin_op_tag(out, in) is semidet.
-:- mode builtin_op_tag(out, ui) is semidet. % Iffy
-:- mode builtin_op_tag(in, in) is semidet. % Implied
-
-%-----------------------------------------------------------------------------%
-% Numeric components shared between comparison, arithmetic, and logic.
-%-----------------------------------------------------------------------------%
-
-% Used to determine if a number is a float or an int.
-:- type number ---> float(float) ; int(int).
-
-%-----------------------------------------------------------------------------%
-% Promotes both numbers to floats.
-:- pred promote(number::in, number::in, float::out, float::out) is det.
-
-%-----------------------------------------------------------------------------%
-% Unifies iff both numbers are the integer functor for the ints
-:- pred as_int(number, number, int, int).
-:- mode as_int(in, in, out, out) is semidet.
-:- mode as_int(di, di, uo, uo) is semidet.
-:- mode as_int(out, out, in, in) is det.
-:- mode as_int(uo, uo, di, di) is det.
-:- mode as_int(in, in, in, in) is semidet. % Implied.
-
-%-----------------------------------------------------------------------------%
-% number_type(NumStr, Num)
-:- pred number_type(string::in, number::uo) is semidet.
-
-%-----------------------------------------------------------------------------%
-% Comparison components.
-%-----------------------------------------------------------------------------%
-
-% Result of the builtin comparisons.
-:- type cmp_result ---> yes ; no ; error(string).
-
-%-----------------------------------------------------------------------------%
-% Runs the builtin comparison predicate.
-:- pred comparison(comparison, element, element, cmp_result).
-:- mode comparison(in, in, in, uo) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- type cmp_pred == (pred(element, element, cmp_result)).
-:- mode cmp_pred == (pred(in, in, uo) is det).
-:- inst cmp_pred == (pred(in, in, uo) is det).
-
-%-----------------------------------------------------------------------------%
-% Comparison builtins. These are aggressively inlined by the compilation
-% phase, so they must be exported to the runtime.
-:- pred builtin_eq `with_type` cmp_pred `with_inst` cmp_pred.
-:- pred builtin_ne `with_type` cmp_pred `with_inst` cmp_pred.
-:- pred builtin_lt `with_type` cmp_pred `with_inst` cmp_pred.
-:- pred builtin_gt `with_type` cmp_pred `with_inst` cmp_pred.
-:- pred builtin_le `with_type` cmp_pred `with_inst` cmp_pred.
-:- pred builtin_ge `with_type` cmp_pred `with_inst` cmp_pred.
-
-%-----------------------------------------------------------------------------%
-
-:- pred builtin_eq_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_ne_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_lt_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_gt_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_le_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_ge_bind `with_type` execute_pred `with_inst` execute_pred.
-    
-%-----------------------------------------------------------------------------%
-% Arithmetic components.
-%-----------------------------------------------------------------------------%
-
-:- pred builtin_plus_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_minus_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_times_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_divide_bind `with_type` execute_pred `with_inst` execute_pred.
-    
-%-----------------------------------------------------------------------------%
-% Define components.
-%-----------------------------------------------------------------------------%
-
-%:- pred builtin_let_bind `with_type` execute_pred `with_inst` execute_pred.
-%:- pred builtin_def_bind `with_type` execute_pred `with_inst` execute_pred.
-:- pred builtin_fn_bind `with_type` execute_pred `with_inst` execute_pred.
-
-%=============================================================================%
-:- implementation.
-%=============================================================================%
-
-:- use_module char.
-:- use_module exception.
-
-:- include_module turbolisp.runtime.builtin.comparison.
-:- import_module turbolisp.runtime.builtin.comparison.
-
-:- include_module turbolisp.runtime.builtin.arithmetic.
-:- import_module turbolisp.runtime.builtin.arithmetic.
-
-%-----------------------------------------------------------------------------%
-
-:- pragma inline(comparison/4).
-:- pragma inline(builtin_op_tag/2).
-:- pragma inline(builtin_op_enum/2).
-
-%-----------------------------------------------------------------------------%
-
-:- pragma inline(comparison/4).
-:- pragma inline(builtin_eq/3).
-:- pragma inline(builtin_lt/3).
-:- pragma inline(builtin_gt/3).
-:- pragma inline(builtin_le/3).
-:- pragma inline(builtin_ge/3).
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(arithmetic) where [
-    ( to_int(E) = I :- builtin_op_enum(arithmetic(E), I) ),
-    ( from_int(I) = E :- builtin_op_enum(arithmetic(E), I) )
-].
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(logic) where [
-    ( to_int(E) = I :- builtin_op_enum(logic(E), I) ),
-    ( from_int(I) = E :- builtin_op_enum(logic(E), I) )
-].
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(comparison) where [
-    ( to_int(E) = I :- builtin_op_enum(comparison(E), I) ),
-    ( from_int(I) = E :- builtin_op_enum(comparison(E), I) )
-].
-
-%-----------------------------------------------------------------------------%
-
-comparison_tag(Cmp, Tag) :-
-    builtin_op_tag(comparison(Cmp), Tag).
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(define) where [
-    ( to_int(E) = I :- builtin_op_enum(define(E), I) ),
-    ( from_int(I) = E :- builtin_op_enum(define(E), I) )
-].
-
-%-----------------------------------------------------------------------------%
-
-:- instance enum.enum(builtin_op) where [
-    ( to_int(E) = I :- builtin_op_enum(E, I) ),
-    ( from_int(I) = E :- builtin_op_enum(E, I) )
-].
-
-%-----------------------------------------------------------------------------%
-
-builtin_op_enum(arithmetic(plus), 0).
-builtin_op_enum(arithmetic(minus), 1).
-builtin_op_enum(arithmetic(times), 2).
-builtin_op_enum(arithmetic(divide), 3).
-builtin_op_enum(logic(int_and), 4).
-builtin_op_enum(logic(int_or), 5).
-builtin_op_enum(logic(int_xor), 6).
-builtin_op_enum(comparison(eq), 7).
-builtin_op_enum(comparison(ne), 8).
-builtin_op_enum(comparison(lt), 9).
-builtin_op_enum(comparison(gt), 10).
-builtin_op_enum(comparison(le), 11).
-builtin_op_enum(comparison(ge), 12).
-builtin_op_enum(define(def), 13).
-builtin_op_enum(define(let), 14).
-builtin_op_enum(define(fn), 15).
-
-%-----------------------------------------------------------------------------%
-
-builtin_op_tag(arithmetic(plus), "+").
-builtin_op_tag(arithmetic(minus), "-").
-builtin_op_tag(arithmetic(times), "*").
-builtin_op_tag(arithmetic(divide), "/").
-builtin_op_tag(logic(int_and), "&").
-builtin_op_tag(logic(int_or), "|").
-builtin_op_tag(logic(int_xor), "^").
-builtin_op_tag(comparison(eq), "=").
-builtin_op_tag(comparison(ne), "!").
-builtin_op_tag(comparison(lt), "<").
-builtin_op_tag(comparison(gt), ">").
-builtin_op_tag(comparison(le), "<=").
-builtin_op_tag(comparison(ge), ">=").
-builtin_op_tag(define(def), "def").
-builtin_op_tag(define(let), "let").
-builtin_op_tag(define(fn), "fn").
-
-%-----------------------------------------------------------------------------%
-
-comparison(eq, E1, E2, Result) :- builtin_eq(E1, E2, Result).
-comparison(ne, E1, E2, Result) :- builtin_ne(E1, E2, Result).
-comparison(lt, E1, E2, Result) :- builtin_lt(E1, E2, Result).
-comparison(gt, E1, E2, Result) :- builtin_gt(E1, E2, Result).
-comparison(le, E1, E2, Result) :- builtin_le(E1, E2, Result).
-comparison(ge, E1, E2, Result) :- builtin_ge(E1, E2, Result).
-
-%-----------------------------------------------------------------------------%
-
-promote(float(A), float(B), A, B).
-promote(int(A), float(B), int_to_float(A), B).
-promote(float(A), int(B), A, int_to_float(B)).
-promote(int(A), int(B), int_to_float(A), int_to_float(B)).
-
-%-----------------------------------------------------------------------------%
-
-as_int(int(A), int(B), A, B).
-
-%-----------------------------------------------------------------------------%
-
-:- pred digit_or_dot(character::in) is semidet.
-digit_or_dot(C) :-
-    ( not C = ('.') ) => char.is_digit(C).
-
-%-----------------------------------------------------------------------------%
-
-number_type(In, Out) :-
-    ( if
-        string.all_match(char.is_digit, In)
-    then
-        string.to_int(In, Int),
-        builtin__copy(Int, UniqInt),
-        Out = int(UniqInt)
-    else if
-        string.all_match(digit_or_dot, In)
-    then
-        string.to_float(In, Float),
-        builtin__copy(Float, UniqFloat),
-        Out = float(UniqFloat)
-    else
-        string.remove_prefix("0x", In, InP),
-        string.all_match(char.is_hex_digit, InP),
-        string.base_string_to_int(16, InP, Int),
-        builtin__copy(Int, UniqInt),
-        Out = int(UniqInt)
-    ).
-
-%-----------------------------------------------------------------------------%
-
-builtin_eq(A, B, Result) :- ( A = B -> Result = yes ; Result = no ).
-
-builtin_ne(A, B, Result) :- ( A = B -> Result = no ; Result = yes ).
-
-builtin_lt(list(_), list(_), error("Error: `lt/2` -> test two lists")).
-builtin_lt(atom(_), list(_), error("Error: `lt/2` -> test atom and list")).
-builtin_lt(list(_), atom(_), error("Error: `lt/2` -> test list and atom")).
-builtin_lt(atom(A), atom(B), Result) :-
-    ( atom_compare(A, B, (<)) -> Result = yes ; Result = no ).
-
-builtin_gt(list(_), list(_), error("Error: `gt/2` -> test two lists")).
-builtin_gt(atom(_), list(_), error("Error: `gt/2` -> test atom and list")).
-builtin_gt(list(_), atom(_), error("Error: `gt/2` -> test list and atom")).
-builtin_gt(atom(A), atom(B), Result) :-
-    ( atom_compare(A, B, (>)) -> Result = yes ; Result = no ).
-
-builtin_le(list(_), list(_), error("Error: `le/2` -> test two lists")).
-builtin_le(atom(_), list(_), error("Error: `le/2` -> test atom and list")).
-builtin_le(list(_), atom(_), error("Error: `le/2` -> test list and atom")).
-builtin_le(atom(A), atom(B), Result) :-
-    ( atom_compare(A, B, (>)) -> Result = no ; Result = yes ).
-
-builtin_ge(list(_), list(_), error("Error: `ge/2` -> test two lists")).
-builtin_ge(atom(_), list(_), error("Error: `ge/2` -> test atom and list")).
-builtin_ge(list(_), atom(_), error("Error: `ge/2` -> test list and atom")).
-builtin_ge(atom(A), atom(B), Result) :-
-    ( atom_compare(A, B, (<)) -> Result = no ; Result = yes ).
-
-%-----------------------------------------------------------------------------%
-
-builtin_eq_bind(E, R, !RT) :- builtin_comparison_bind(builtin_eq, E, R, !RT).
-builtin_ne_bind(E, R, !RT) :- builtin_comparison_bind(builtin_ne, E, R, !RT).
-builtin_lt_bind(E, R, !RT) :- builtin_comparison_bind(builtin_lt, E, R, !RT).
-builtin_gt_bind(E, R, !RT) :- builtin_comparison_bind(builtin_gt, E, R, !RT).
-builtin_le_bind(E, R, !RT) :- builtin_comparison_bind(builtin_le, E, R, !RT).
-builtin_ge_bind(E, R, !RT) :- builtin_comparison_bind(builtin_ge, E, R, !RT).
-
-%-----------------------------------------------------------------------------%
-
-builtin_plus_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_plus, plus, E, R).
-builtin_minus_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_minus, minus, E, R).
-builtin_times_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_times, times, E, R).
-builtin_divide_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_divide, divide, E, R).
-
-%-----------------------------------------------------------------------------%
-% Used to implement let and def
-
-%-----------------------------------------------------------------------------%
-% Used to parse argument names in fn/3
-:- pred fn_arg(element, string, int, int, maybe.maybe_error, maybe.maybe_error).
-:- mode fn_arg(in, out, in, out, di, uo) is det.
-%:- mode fn_arg(di, uo, in, out, di, uo) is det.
-
-fn_arg(_, "", I, inc(I), maybe.error(E), maybe.error(E)).
-fn_arg(list(_), "", I, inc(I), maybe.ok,
-    maybe.error(string.append(string.append(
-        "Error: `fn/3` -> Arg list element ",
-        string.from_int(I)),
-        " is a list"))).
-fn_arg(atom(Str), Str, I, inc(I), maybe.ok, maybe.ok).
-
-%-----------------------------------------------------------------------------%
-% Used to implement fn
-:- type fn_parse_result == {string, list(string), list(element), int}.
-:- pred fn_parse(list.list(element), maybe.maybe_error(fn_parse_result)).
-:- mode fn_parse(in, res_uo) is det.
-
-fn_parse(Element, Result) :-
-    ( if
-        Element = [NameElement|[ArgsElement|Body]]
-    then
-        (
-            NameElement = list(_),
-            Result = maybe.error("Error: `fn/3` -> arg 1 is a list")
-        ;
-            NameElement = atom(Name),
-            (
-                ArgsElement = atom(_),
-                Result = maybe.error("Error: `fn/3` -> arg 2 is an atom")
-            ;
-                ArgsElement = list(Args),
-                % Validate the arguments, and construct a list of names.
-                list.map_foldl2(fn_arg,
-                    Args, ArgNames, 0, Arity, maybe.ok, ArgsResult),
-                (
-                    ArgsResult = maybe.ok,
-                    Result = maybe.ok({Name, ArgNames, Body, Arity})
-                ;
-                    ArgsResult = maybe.error(Error),
-                    Result = maybe.error(Error)
-                )
-            )
-        )
-    else
-        exception.throw(exception.software_error(
-            "Wrong arity in `fn/3` (builtin_bind is probably broken)"))
-    ).
-
-%-----------------------------------------------------------------------------%
-
-builtin_fn_bind(Element, Result, !Runtime) :-
-    fn_parse(Element, FnResult),
-    (
-        FnResult = maybe.error(Error),
-        Result = maybe.error(Error)
-    ;
-        FnResult = maybe.ok({Name, ArgNames, Body, Arity}),
-        def_bind(args(Name, Arity), lisp_bind(ArgNames, Body), !Runtime),
-        Result = maybe.ok(atom(Name))
-    ).
+% Copyright (c) 2019  AlaskanEmily, Transnat Games
+%
+% This Source Code Form is subject to the terms of the Mozilla Public
+% License, v. 2.0. If a copy of the MPL was not distributed with this
+% file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+:- module turbolisp.runtime.builtin.
+
+%=============================================================================%
+% TurboLisp builtins
+:- interface.
+%=============================================================================%
+
+:- use_module enum.
+
+%-----------------------------------------------------------------------------%
+
+:- type arithmetic --->
+    plus ;
+    minus ;
+    times ;
+    divide.
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(arithmetic).
+
+%-----------------------------------------------------------------------------%
+
+:- type logic --->
+    int_and ;
+    int_or ;
+    int_xor.
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(logic).
+
+%-----------------------------------------------------------------------------%
+
+:- type comparison --->
+    eq ;
+    ne ;
+    lt ;
+    gt ;
+    le ;
+    ge.
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(comparison).
+
+%-----------------------------------------------------------------------------%
+
+:- pred comparison_tag(comparison, string).
+:- mode comparison_tag(in, out) is det.
+:- mode comparison_tag(out, in) is semidet.
+:- mode comparison_tag(out, ui) is semidet. % Iffy
+:- mode comparison_tag(in, in) is semidet. % Implied
+
+%-----------------------------------------------------------------------------%
+
+:- type define --->
+    def ;
+    let ;
+    fn.
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(define).
+
+%-----------------------------------------------------------------------------%
+
+:- type builtin_op --->
+    arithmetic(arithmetic) ;
+    logic(logic) ;
+    comparison(comparison) ;
+    define(define).
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(builtin_op).
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_op_enum(builtin_op, int).
+:- mode builtin_op_enum(in, out) is det.
+:- mode builtin_op_enum(out, in) is semidet.
+:- mode builtin_op_enum(in, in) is semidet. % Implied
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_op_tag(builtin_op, string).
+:- mode builtin_op_tag(in, out) is det.
+:- mode builtin_op_tag(out, in) is semidet.
+:- mode builtin_op_tag(out, ui) is semidet. % Iffy
+:- mode builtin_op_tag(in, in) is semidet. % Implied
+
+%-----------------------------------------------------------------------------%
+% Numeric components shared between comparison, arithmetic, and logic.
+%-----------------------------------------------------------------------------%
+
+% Used to determine if a number is a float or an int.
+:- type number ---> float(float) ; int(int).
+
+%-----------------------------------------------------------------------------%
+% Promotes both numbers to floats.
+:- pred promote(number::in, number::in, float::out, float::out) is det.
+
+%-----------------------------------------------------------------------------%
+% Unifies iff both numbers are the integer functor for the ints
+:- pred as_int(number, number, int, int).
+:- mode as_int(in, in, out, out) is semidet.
+:- mode as_int(di, di, uo, uo) is semidet.
+:- mode as_int(out, out, in, in) is det.
+:- mode as_int(uo, uo, di, di) is det.
+:- mode as_int(in, in, in, in) is semidet. % Implied.
+
+%-----------------------------------------------------------------------------%
+% number_type(NumStr, Num)
+:- pred number_type(string::in, number::uo) is semidet.
+
+%-----------------------------------------------------------------------------%
+% Comparison components.
+%-----------------------------------------------------------------------------%
+
+% Result of the builtin comparisons.
+:- type cmp_result ---> yes ; no ; error(string).
+
+%-----------------------------------------------------------------------------%
+% Runs the builtin comparison predicate.
+:- pred comparison(comparison, element, element, cmp_result).
+:- mode comparison(in, in, in, uo) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- type cmp_pred == (pred(element, element, cmp_result)).
+:- mode cmp_pred == (pred(in, in, uo) is det).
+:- inst cmp_pred == (pred(in, in, uo) is det).
+
+%-----------------------------------------------------------------------------%
+% Comparison builtins. These are aggressively inlined by the compilation
+% phase, so they must be exported to the runtime.
+:- pred builtin_eq `with_type` cmp_pred `with_inst` cmp_pred.
+:- pred builtin_ne `with_type` cmp_pred `with_inst` cmp_pred.
+:- pred builtin_lt `with_type` cmp_pred `with_inst` cmp_pred.
+:- pred builtin_gt `with_type` cmp_pred `with_inst` cmp_pred.
+:- pred builtin_le `with_type` cmp_pred `with_inst` cmp_pred.
+:- pred builtin_ge `with_type` cmp_pred `with_inst` cmp_pred.
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_eq_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_ne_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_lt_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_gt_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_le_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_ge_bind `with_type` execute_pred `with_inst` execute_pred.
+    
+%-----------------------------------------------------------------------------%
+% Arithmetic components.
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_plus_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_minus_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_times_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_divide_bind `with_type` execute_pred `with_inst` execute_pred.
+    
+%-----------------------------------------------------------------------------%
+% Define components.
+%-----------------------------------------------------------------------------%
+
+%:- pred builtin_let_bind `with_type` execute_pred `with_inst` execute_pred.
+%:- pred builtin_def_bind `with_type` execute_pred `with_inst` execute_pred.
+:- pred builtin_fn_bind `with_type` execute_pred `with_inst` execute_pred.
+
+%=============================================================================%
+:- implementation.
+%=============================================================================%
+
+:- use_module char.
+:- use_module exception.
+
+:- include_module turbolisp.runtime.builtin.comparison.
+:- import_module turbolisp.runtime.builtin.comparison.
+
+:- include_module turbolisp.runtime.builtin.arithmetic.
+:- import_module turbolisp.runtime.builtin.arithmetic.
+
+%-----------------------------------------------------------------------------%
+
+:- pragma inline(comparison/4).
+:- pragma inline(builtin_op_tag/2).
+:- pragma inline(builtin_op_enum/2).
+
+%-----------------------------------------------------------------------------%
+
+:- pragma inline(comparison/4).
+:- pragma inline(builtin_eq/3).
+:- pragma inline(builtin_lt/3).
+:- pragma inline(builtin_gt/3).
+:- pragma inline(builtin_le/3).
+:- pragma inline(builtin_ge/3).
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(arithmetic) where [
+    ( to_int(E) = I :- builtin_op_enum(arithmetic(E), I) ),
+    ( from_int(I) = E :- builtin_op_enum(arithmetic(E), I) )
+].
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(logic) where [
+    ( to_int(E) = I :- builtin_op_enum(logic(E), I) ),
+    ( from_int(I) = E :- builtin_op_enum(logic(E), I) )
+].
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(comparison) where [
+    ( to_int(E) = I :- builtin_op_enum(comparison(E), I) ),
+    ( from_int(I) = E :- builtin_op_enum(comparison(E), I) )
+].
+
+%-----------------------------------------------------------------------------%
+
+comparison_tag(Cmp, Tag) :-
+    builtin_op_tag(comparison(Cmp), Tag).
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(define) where [
+    ( to_int(E) = I :- builtin_op_enum(define(E), I) ),
+    ( from_int(I) = E :- builtin_op_enum(define(E), I) )
+].
+
+%-----------------------------------------------------------------------------%
+
+:- instance enum.enum(builtin_op) where [
+    ( to_int(E) = I :- builtin_op_enum(E, I) ),
+    ( from_int(I) = E :- builtin_op_enum(E, I) )
+].
+
+%-----------------------------------------------------------------------------%
+
+builtin_op_enum(arithmetic(plus), 0).
+builtin_op_enum(arithmetic(minus), 1).
+builtin_op_enum(arithmetic(times), 2).
+builtin_op_enum(arithmetic(divide), 3).
+builtin_op_enum(logic(int_and), 4).
+builtin_op_enum(logic(int_or), 5).
+builtin_op_enum(logic(int_xor), 6).
+builtin_op_enum(comparison(eq), 7).
+builtin_op_enum(comparison(ne), 8).
+builtin_op_enum(comparison(lt), 9).
+builtin_op_enum(comparison(gt), 10).
+builtin_op_enum(comparison(le), 11).
+builtin_op_enum(comparison(ge), 12).
+builtin_op_enum(define(def), 13).
+builtin_op_enum(define(let), 14).
+builtin_op_enum(define(fn), 15).
+
+%-----------------------------------------------------------------------------%
+
+builtin_op_tag(arithmetic(plus), "+").
+builtin_op_tag(arithmetic(minus), "-").
+builtin_op_tag(arithmetic(times), "*").
+builtin_op_tag(arithmetic(divide), "/").
+builtin_op_tag(logic(int_and), "&").
+builtin_op_tag(logic(int_or), "|").
+builtin_op_tag(logic(int_xor), "^").
+builtin_op_tag(comparison(eq), "=").
+builtin_op_tag(comparison(ne), "!").
+builtin_op_tag(comparison(lt), "<").
+builtin_op_tag(comparison(gt), ">").
+builtin_op_tag(comparison(le), "<=").
+builtin_op_tag(comparison(ge), ">=").
+builtin_op_tag(define(def), "def").
+builtin_op_tag(define(let), "let").
+builtin_op_tag(define(fn), "fn").
+
+%-----------------------------------------------------------------------------%
+
+comparison(eq, E1, E2, Result) :- builtin_eq(E1, E2, Result).
+comparison(ne, E1, E2, Result) :- builtin_ne(E1, E2, Result).
+comparison(lt, E1, E2, Result) :- builtin_lt(E1, E2, Result).
+comparison(gt, E1, E2, Result) :- builtin_gt(E1, E2, Result).
+comparison(le, E1, E2, Result) :- builtin_le(E1, E2, Result).
+comparison(ge, E1, E2, Result) :- builtin_ge(E1, E2, Result).
+
+%-----------------------------------------------------------------------------%
+
+promote(float(A), float(B), A, B).
+promote(int(A), float(B), int_to_float(A), B).
+promote(float(A), int(B), A, int_to_float(B)).
+promote(int(A), int(B), int_to_float(A), int_to_float(B)).
+
+%-----------------------------------------------------------------------------%
+
+as_int(int(A), int(B), A, B).
+
+%-----------------------------------------------------------------------------%
+
+:- pred digit_or_dot(character::in) is semidet.
+digit_or_dot(C) :-
+    ( not C = ('.') ) => char.is_digit(C).
+
+%-----------------------------------------------------------------------------%
+
+number_type(In, Out) :-
+    ( if
+        string.all_match(char.is_digit, In)
+    then
+        string.to_int(In, Int),
+        builtin__copy(Int, UniqInt),
+        Out = int(UniqInt)
+    else if
+        string.all_match(digit_or_dot, In)
+    then
+        string.to_float(In, Float),
+        builtin__copy(Float, UniqFloat),
+        Out = float(UniqFloat)
+    else
+        string.remove_prefix("0x", In, InP),
+        string.all_match(char.is_hex_digit, InP),
+        string.base_string_to_int(16, InP, Int),
+        builtin__copy(Int, UniqInt),
+        Out = int(UniqInt)
+    ).
+
+%-----------------------------------------------------------------------------%
+
+builtin_eq(A, B, Result) :- ( A = B -> Result = yes ; Result = no ).
+
+builtin_ne(A, B, Result) :- ( A = B -> Result = no ; Result = yes ).
+
+builtin_lt(list(_), list(_), error("Error: `lt/2` -> test two lists")).
+builtin_lt(atom(_), list(_), error("Error: `lt/2` -> test atom and list")).
+builtin_lt(list(_), atom(_), error("Error: `lt/2` -> test list and atom")).
+builtin_lt(atom(A), atom(B), Result) :-
+    ( atom_compare(A, B, (<)) -> Result = yes ; Result = no ).
+
+builtin_gt(list(_), list(_), error("Error: `gt/2` -> test two lists")).
+builtin_gt(atom(_), list(_), error("Error: `gt/2` -> test atom and list")).
+builtin_gt(list(_), atom(_), error("Error: `gt/2` -> test list and atom")).
+builtin_gt(atom(A), atom(B), Result) :-
+    ( atom_compare(A, B, (>)) -> Result = yes ; Result = no ).
+
+builtin_le(list(_), list(_), error("Error: `le/2` -> test two lists")).
+builtin_le(atom(_), list(_), error("Error: `le/2` -> test atom and list")).
+builtin_le(list(_), atom(_), error("Error: `le/2` -> test list and atom")).
+builtin_le(atom(A), atom(B), Result) :-
+    ( atom_compare(A, B, (>)) -> Result = no ; Result = yes ).
+
+builtin_ge(list(_), list(_), error("Error: `ge/2` -> test two lists")).
+builtin_ge(atom(_), list(_), error("Error: `ge/2` -> test atom and list")).
+builtin_ge(list(_), atom(_), error("Error: `ge/2` -> test list and atom")).
+builtin_ge(atom(A), atom(B), Result) :-
+    ( atom_compare(A, B, (<)) -> Result = no ; Result = yes ).
+
+%-----------------------------------------------------------------------------%
+
+builtin_eq_bind(E, R, !RT) :- builtin_comparison_bind(builtin_eq, E, R, !RT).
+builtin_ne_bind(E, R, !RT) :- builtin_comparison_bind(builtin_ne, E, R, !RT).
+builtin_lt_bind(E, R, !RT) :- builtin_comparison_bind(builtin_lt, E, R, !RT).
+builtin_gt_bind(E, R, !RT) :- builtin_comparison_bind(builtin_gt, E, R, !RT).
+builtin_le_bind(E, R, !RT) :- builtin_comparison_bind(builtin_le, E, R, !RT).
+builtin_ge_bind(E, R, !RT) :- builtin_comparison_bind(builtin_ge, E, R, !RT).
+
+%-----------------------------------------------------------------------------%
+
+builtin_plus_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_plus, plus, E, R).
+builtin_minus_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_minus, minus, E, R).
+builtin_times_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_times, times, E, R).
+builtin_divide_bind(E, R, !RT) :- builtin_arithmetic_bind(builtin_divide, divide, E, R).
+
+%-----------------------------------------------------------------------------%
+% Used to implement let and def
+
+%-----------------------------------------------------------------------------%
+% Used to parse argument names in fn/3
+:- pred fn_arg(element, string, int, int, maybe.maybe_error, maybe.maybe_error).
+:- mode fn_arg(in, out, in, out, di, uo) is det.
+%:- mode fn_arg(di, uo, in, out, di, uo) is det.
+
+fn_arg(_, "", I, inc(I), maybe.error(E), maybe.error(E)).
+fn_arg(list(_), "", I, inc(I), maybe.ok,
+    maybe.error(string.append(string.append(
+        "Error: `fn/3` -> Arg list element ",
+        string.from_int(I)),
+        " is a list"))).
+fn_arg(atom(Str), Str, I, inc(I), maybe.ok, maybe.ok).
+
+%-----------------------------------------------------------------------------%
+% Used to implement fn
+:- type fn_parse_result == {string, list(string), list(element), int}.
+:- pred fn_parse(list.list(element), maybe.maybe_error(fn_parse_result)).
+:- mode fn_parse(in, res_uo) is det.
+
+fn_parse(Element, Result) :-
+    ( if
+        Element = [NameElement|[ArgsElement|Body]]
+    then
+        (
+            NameElement = list(_),
+            Result = maybe.error("Error: `fn/3` -> arg 1 is a list")
+        ;
+            NameElement = atom(Name),
+            (
+                ArgsElement = atom(_),
+                Result = maybe.error("Error: `fn/3` -> arg 2 is an atom")
+            ;
+                ArgsElement = list(Args),
+                % Validate the arguments, and construct a list of names.
+                list.map_foldl2(fn_arg,
+                    Args, ArgNames, 0, Arity, maybe.ok, ArgsResult),
+                (
+                    ArgsResult = maybe.ok,
+                    Result = maybe.ok({Name, ArgNames, Body, Arity})
+                ;
+                    ArgsResult = maybe.error(Error),
+                    Result = maybe.error(Error)
+                )
+            )
+        )
+    else
+        exception.throw(exception.software_error(
+            "Wrong arity in `fn/3` (builtin_bind is probably broken)"))
+    ).
+
+%-----------------------------------------------------------------------------%
+
+builtin_fn_bind(Element, Result, !Runtime) :-
+    fn_parse(Element, FnResult),
+    (
+        FnResult = maybe.error(Error),
+        Result = maybe.error(Error)
+    ;
+        FnResult = maybe.ok({Name, ArgNames, Body, Arity}),
+        def_bind(args(Name, Arity), lisp_bind(ArgNames, Body), !Runtime),
+        Result = maybe.ok(atom(Name))
+    ).

--- a/turbolisp.runtime.m
+++ b/turbolisp.runtime.m
@@ -1,800 +1,800 @@
-% Copyright (c) 2019  AlaskanEmily, Transnat Games
-%
-% This Source Code Form is subject to the terms of the Mozilla Public
-% License, v. 2.0. If a copy of the MPL was not distributed with this
-% file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-:- module turbolisp.runtime.
-
-%=============================================================================%
-% TurboLisp runtime components.
-:- interface.
-%=============================================================================%
-
-:- import_module list.
-:- use_module assoc_list.
-:- use_module rbtree.
-:- use_module maybe.
-
-%-----------------------------------------------------------------------------%
-% TODO!
-:- func nil = element.
-
-%-----------------------------------------------------------------------------%
-% Frames use an assoc list, as they are not expected to have a lot of elements,
-% and the extra allocations of a tree would quickly overwhelm the gains in
-% lookup speed.
-:- type frame --->
-    frame(variables::assoc_list.assoc_list(string, element)).
-
-%-----------------------------------------------------------------------------%
-
-:- func init_frame = frame.
-
-%-----------------------------------------------------------------------------%
-
-:- func init_frame(assoc_list.assoc_list(string, element)) = frame.
-
-%-----------------------------------------------------------------------------%
-
-:- type result == maybe.maybe_error(element).
-
-%-----------------------------------------------------------------------------%
-
-:- inst maybe_unique_error --->
-    maybe.ok(ground) ;
-    maybe.error(unique).
-
-:- inst maybe_clobbered_error --->
-    maybe.ok(ground) ;
-    maybe.error(clobbered).
-
-:- mode res_uo == free >> maybe_unique_error.
-:- mode res_di == maybe_unique_error >> maybe_clobbered_error.
-
-%-----------------------------------------------------------------------------%
-
-:- type execute_pred == (pred(list.list(element), result, runtime, runtime)).
-:- inst execute_pred == (pred(in, res_uo, in, out) is det).
-:- mode execute_pred == (pred(in, res_uo, in, out) is det).
-
-:- type bind --->
-    mercury_bind(pred(list.list(element)::in, result::res_uo, runtime::in, runtime::out) is det) ;
-    lisp_bind(arg_names::list.list(string), body::list.list(element)).
-
-%-----------------------------------------------------------------------------%
-
-:- type bind_spec --->
-    variadic(string) ;
-    args(string, int).
-
-%-----------------------------------------------------------------------------%
-
-:- type variables == rbtree.rbtree(string, element).
-
-%-----------------------------------------------------------------------------%
-
-:- type runtime ---> runtime(
-    globals::variables,
-    binds::rbtree.rbtree(bind_spec, bind),
-    stack_frames::list.list(frame),
-    pending_io::list.list(string)).
-
-%-----------------------------------------------------------------------------%
-
-:- func init = runtime.
-
-%-----------------------------------------------------------------------------%
-
-:- pred push_stack_frame(runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred push_stack_frame(assoc_list.assoc_list(string, element)::in,
-    runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred pop_stack_frame(runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred push_stack_frame_check(int::out, runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred push_stack_frame_check(assoc_list.assoc_list(string, element)::in,
-    int::out, runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred pop_stack_frame_check(int::in, runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred def_var(string::in, element::in, runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred find_var(list.list(frame), rbtree.rbtree(string, element), string, element).
-:- mode find_var(in, in, in, out) is semidet.
-
-%-----------------------------------------------------------------------------%
-
-:- pred builtin_bind(bind_spec::in, bind::out) is semidet.
-
-%-----------------------------------------------------------------------------%
-
-:- pred def_bind(bind_spec::in, bind::in, runtime::in, runtime::out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- pred find_bind(string, int, rbtree.rbtree(bind_spec, bind), bind).
-:- mode find_bind(in, in, in, out) is semidet.
-
-%-----------------------------------------------------------------------------%
-% This is a workaround, as the Mercury compiler gets confused when disjuncting
-% on functors which contain predicates as elements in the functor.
-:- pred call_bind(bind, list.list(element), result, runtime, runtime).
-:- mode call_bind(in, in, res_uo, in, out) is det.
-
-%-----------------------------------------------------------------------------%
-
-:- type run_pred1 == (pred(element, result, runtime, runtime)).
-:- inst run_pred1 == (pred(in, res_uo, in, out) is det).
-:- mode run_pred1 == (pred(in, res_uo, in, out) is det).
-
-%-----------------------------------------------------------------------------%
-% Same as run_pred1, but is suitable for use with list.map_foldl2
-:- type run_pred2 == (pred(element, element,
-    runtime, runtime,
-    maybe.maybe_error, maybe.maybe_error)).
-:- inst run_pred2 == (pred(in, out, in, out, di, uo) is det).
-:- mode run_pred2 == (pred(in, out, in, out, di, uo) is det).
-
-%-----------------------------------------------------------------------------%
-% Same as run_pred1, but is suitable for use with list.map_foldl3 while
-% counting elements in the list.
-:- type run_pred3 == (pred(element, element,
-    runtime, runtime,
-    int, int,
-    maybe.maybe_error, maybe.maybe_error)).
-:- inst run_pred3 == (pred(in, out, in, out, in, out, di, uo) is det).
-:- mode run_pred3 == (pred(in, out, in, out, in, out, di, uo) is det).
-
-%-----------------------------------------------------------------------------%
-
-:- pred reduce `with_type` run_pred1 `with_inst` run_pred1.
-:- pred reduce `with_type` run_pred2 `with_inst` run_pred2.
-:- pred reduce `with_type` run_pred3 `with_inst` run_pred3.
-
-%-----------------------------------------------------------------------------%
-
-:- pred execute `with_type` run_pred1 `with_inst` run_pred1.
-:- pred execute `with_type` run_pred2 `with_inst` run_pred2.
-:- pred execute `with_type` run_pred3 `with_inst` run_pred3.
-
-%=============================================================================%
-:- implementation.
-%=============================================================================%
-
-:- use_module exception.
-:- use_module int.
-:- use_module string.
-:- use_module pair.
-
-:- include_module turbolisp.runtime.builtin.
-:- use_module turbolisp.runtime.builtin.
-
-%-----------------------------------------------------------------------------%
-
-nil = list([]).
-
-%-----------------------------------------------------------------------------%
-% Used for the optimized C routines.
-:- pragma foreign_decl("C", "
-#ifdef _MSC_VER
-
-#define TL_YIELD_ARITY(ARITY, DST, OUT) \\
-    _ltoa_s((ARITY), (OUT), 77, 10); \\
-    (OUT)[76] = 0; \\
-    const MR_Integer DST = strnlen_s((OUT), 77)
-
-#else
-
-#define TL_YIELD_ARITY(ARITY, DST, OUT) \\
-    const MR_Integer DST = sprintf((OUT), ""%i"", (ARITY))
-
-#endif
-
-#define TL_YIELD_FUNC_NAME(NAME, NAME_LEN, ARITY, END, OUT) do { \\
-    (OUT)[0] = '`'; \\
-    memcpy((OUT)+1, Name, (NAME_LEN)); \\
-    (OUT)[(NAME_LEN)+1] = '/'; \\
-    { \\
-        const MR_Integer arity_start = (NAME_LEN)+2; \\
-        TL_YIELD_ARITY((ARITY), ZZ_end, (OUT) + arity_start) + arity_start; \\
-        (OUT)[ZZ_end] = '`'; \\
-        (END) = ZZ_end+1; \\
-    } \\
-    \\
-}while(0)
-
-").
-
-%-----------------------------------------------------------------------------%
-
-:- func yield_func_name(string::in, int::in) = (string::uo) is det.
-yield_func_name(Name, Arity) = string.append(TickFuncArity, "`") :-
-    string.first_char(ArityString, ('/'), string.from_int(Arity)),
-    string.first_char(TickFuncName, ('`'), Name),
-    string.append(TickFuncName, ArityString, TickFuncArity).
-
-% Optimized C version.
-:- pragma foreign_proc("C", yield_func_name(Name::in, Arity::in) = (Out::uo),
-    [promise_pure, thread_safe, will_not_call_mercury, will_not_modify_trail,
-     does_not_affect_liveness, may_duplicate],
-    "
-    const MR_Integer name_len = strlen(Name);
-    MR_allocate_aligned_string_msg(Out, name_len + 80, MR_ALLOC_ID);
-    MR_Integer end;
-    TL_YIELD_FUNC_NAME(Name, name_len, Arity, end, Out);
-    Out[end] = 0;
-    ").
-
-%-----------------------------------------------------------------------------%
-
-:- func func_error(string::in, int::in, string::in) = (string::uo) is det.
-func_error(Name, Arity, Error) =
-    string.append(func_error_prefix(Name, Arity), Error).
-
-%-----------------------------------------------------------------------------%
-
-:- func func_error_prefix(string::in, int::in) = (string::uo) is det.
-func_error_prefix(Name, Arity) =
-    string.append(
-    string.append(
-        "Error ",
-        yield_func_name(Name, Arity)),
-        " -> ").
-
-% Optimized C version.
-:- pragma foreign_proc("C", func_error(Name::in, Arity::in, Error::in) = (Out::uo),
-    [promise_pure, thread_safe, will_not_call_mercury, will_not_modify_trail,
-     does_not_affect_liveness, may_duplicate],
-    "
-    const char head[] = {'E', 'r', 'r', 'o', 'r', ':', ' '};
-    const char tail[] = {' ', '-', '>', ' '};
-    const MR_Integer name_len = strlen(Name);
-    const MR_Integer error_len = strlen(Error);
-    MR_allocate_aligned_string_msg(Out, name_len + error_len + 90, MR_ALLOC_ID);
-    MR_Integer end;
-    memcpy(Out, head, sizeof(head));
-    TL_YIELD_FUNC_NAME(Name, name_len, Arity, end, Out+sizeof(head));
-    memcpy(Out+sizeof(head)+end, tail, sizeof(tail));
-    memcpy(Out+sizeof(head)+sizeof(tail)+end, Error, error_len+1);
-    ").
-
-%-----------------------------------------------------------------------------%
-
-:- func list_index_error(int::in, int::in) = (string::uo) is det.
-list_index_error(At, Length) = Result :-
-    string.append("`at` -> index of '", string.from_int(At), Err0),
-    string.append(Err0, "' out of bounds for list of length '", Err1),
-    string.append(Err1, string.from_int(Length), Err2),
-    string.append(Err2, "'", Result).
-
-% Optimized C version.
-:- pragma foreign_proc("C", list_index_error(At::in, Length::in) = (Out::uo),
-    [promise_pure, thread_safe, will_not_call_mercury, will_not_modify_trail,
-     does_not_affect_liveness, may_duplicate],
-    "
-        MR_allocate_aligned_string_msg(Out, 160, MR_ALLOC_ID);
-        snprintf(Out, 159,
-            ""`at` -> index of '%i' out of bounds for list of length '%i'"",
-            At, Length);
-        Out[159] = 0;
-    ").
-
-%-----------------------------------------------------------------------------%
-
-init_frame(Variables) = frame(Variables).
-init_frame = init_frame([]).
-
-%-----------------------------------------------------------------------------%
-
-init = runtime(rbtree.init, rbtree.init, [], []).
-
-%-----------------------------------------------------------------------------%
-
-push_stack_frame(Variables, runtime(G, B, Frames, PIO),
-    runtime(G, B, [init_frame(Variables)|Frames], PIO)).
-
-%-----------------------------------------------------------------------------%
-
-push_stack_frame(runtime(G, B, Frames, PIO),
-    runtime(G, B, [init_frame|Frames], PIO)).
-
-%-----------------------------------------------------------------------------%
-
-pop_stack_frame(runtime(G, B, [_Head|Frames], PIO),
-    runtime(G, B, Frames, PIO)) :-
-    % trace [io(!IO)] (
-    %     rbtree.keys(Head ^ variables, Keys),
-    %     io.write_string("Pop losing ", !IO),
-    %     io.write_int(list.length(Keys), !IO), io.nl(!IO),
-    %     list.foldl(
-    %         (pred(Str::in, I::di, O::uo) is semidet :-
-    %             io.write_string(Str, I, M), io.nl(M, O)),
-    %         Keys, !IO)
-    % ),
-    true.
-
-pop_stack_frame(runtime(_, _, [], _), _) :-
-    exception.throw(exception.software_error("Stack underflow")).
-
-%-----------------------------------------------------------------------------%
-
-push_stack_frame_check(Check, !Runtime) :-
-    push_stack_frame(!Runtime),
-    list.length(!.Runtime ^ stack_frames, Check).
-
-%-----------------------------------------------------------------------------%
-
-push_stack_frame_check(Variables, Check, !Runtime) :-
-    push_stack_frame(Variables, !Runtime),
-    list.length(!.Runtime ^ stack_frames, Check).
-
-%-----------------------------------------------------------------------------%
-
-pop_stack_frame_check(Check, !Runtime) :-
-    ( if
-        list.length(!.Runtime ^ stack_frames, Check)
-    then
-       pop_stack_frame(!Runtime)
-    else
-        exception.throw(exception.software_error("Stack mismatch"))
-    ).
-
-%-----------------------------------------------------------------------------%
-
-def_var(Name, Value, !Runtime) :-
-    !.Runtime ^ stack_frames = StackFrames,
-    (
-        StackFrames = [frame(In)|Tail],
-        
-        ( assoc_list.remove(In, Name, _, V) -> Out = V ; Out = In ),
-        
-        !Runtime ^ stack_frames := [frame([pair.pair(Name, Value)|Out])|Tail]
-    ;
-        StackFrames = [],
-        
-        !.Runtime ^ globals = In,
-        rbtree.set(Name, Value, In, Out),
-        !Runtime ^ globals := Out
-    ).
-
-%-----------------------------------------------------------------------------%
-
-find_var([], Globals, Name, Value) :- rbtree.search(Globals, Name, Value).
-find_var([frame(Head)|Tail], Globals, Name, Value) :-
-    ( if
-        assoc_list.search(Head, Name, SemiValue)
-    then
-        Value = SemiValue
-    else
-        find_var(Tail, Globals, Name, Value)
-    ).
-
-%-----------------------------------------------------------------------------%
-
-builtin_bind(args("=", 4), mercury_bind(turbolisp__runtime__builtin__builtin_eq_bind)).
-builtin_bind(args("!", 4), mercury_bind(turbolisp__runtime__builtin__builtin_ne_bind)).
-builtin_bind(args("<", 4), mercury_bind(turbolisp__runtime__builtin__builtin_lt_bind)).
-builtin_bind(args(">", 4), mercury_bind(turbolisp__runtime__builtin__builtin_gt_bind)).
-builtin_bind(args("<=", 4), mercury_bind(turbolisp__runtime__builtin__builtin_le_bind)).
-builtin_bind(args(">=", 4), mercury_bind(turbolisp__runtime__builtin__builtin_ge_bind)).
-
-builtin_bind(args("+", 2), mercury_bind(turbolisp__runtime__builtin__builtin_plus_bind)).
-builtin_bind(args("-", 2), mercury_bind(turbolisp__runtime__builtin__builtin_minus_bind)).
-builtin_bind(args("*", 2), mercury_bind(turbolisp__runtime__builtin__builtin_times_bind)).
-builtin_bind(args("/", 2), mercury_bind(turbolisp__runtime__builtin__builtin_divide_bind)).
-
-builtin_bind(args("fn", 3), mercury_bind(turbolisp__runtime__builtin__builtin_fn_bind)).
-
-%-----------------------------------------------------------------------------%
-
-def_bind(BindSpec, Bind, !Runtime) :-
-    Binds = !.Runtime ^ binds,
-    !Runtime ^ binds := rbtree.set(Binds, BindSpec, Bind).
-
-%-----------------------------------------------------------------------------%
-
-find_bind(Name, Arity, Tree, Out) :-
-    % Try for set args before trying for variadic args.
-    Args = args(Name, Arity), Variadic = variadic(Name),
-    ( if
-        rbtree.search(Tree, Args, Bind)
-    then
-        Out = Bind
-    else if
-        builtin_bind(Args, Bind)
-    then
-        Out = Bind
-    else if
-        rbtree.search(Tree, Variadic, Bind)
-    then
-        Out = Bind
-    else
-        builtin_bind(Variadic, Out)
-    ).
-
-%-----------------------------------------------------------------------------%
-
-call_bind(mercury_bind(Pred), Args, Result, !Runtime) :-
-    call(Pred, Args, Result:result, !Runtime).
-
-call_bind(lisp_bind(ArgNames, Body), Args, Result, !Runtime) :-
-    
-    assoc_list.from_corresponding_lists(ArgNames, Args, Variables),
-    
-    % This is needed both for a func call, and just to yield the reduced
-    % version of this list if it is not executable.
-    push_stack_frame_check(Variables, Check, !Runtime),
-    % trace [io(!IO)] ( io.write_string("Push stack from in call_bind\n", !IO) ),
-    
-    list.map_foldl2(execute, Body, Values, !Runtime, maybe.ok, CallResult),
-    
-    % trace [io(!IO)] ( io.write_string("Pop stack from in call_bind\n", !IO) ),
-    pop_stack_frame_check(Check, !Runtime),
-    
-    (
-        CallResult = maybe.ok,
-        ( if
-            list.last(Values, Last)
-        then
-            Result = maybe.ok(Last)
-        else
-            Result = maybe.ok(nil)
-        )
-    ;
-        CallResult = maybe.error(Error),
-        Result = maybe.error(Error)
-    ).
-
-%-----------------------------------------------------------------------------%
-% Result of preprocessing.
-% Comparison is a special case because of laziness.
-:- type preprocess_result --->
-    reduced(element) ; % Result is fully reduced.
-    execute(string, list(element), preprocess_arity::int) ; % Result is a call.
-    comparison(turbolisp.runtime.builtin.comparison, element, element, list(element)).
-
-%-----------------------------------------------------------------------------%
-% Performs preprocessing logic which is shared between reduce and execute.
-:- pred preprocess(run_pred3, element, maybe.maybe_error(preprocess_result), runtime, runtime).
-:- mode preprocess(run_pred3, in, res_uo, in, out) is det.
-
-% Pass atoms through unchanged.
-preprocess(_, atom(Str), maybe.ok(reduced(atom(Str))), !Runtime).
-
-% Empty list, nothing to do.
-preprocess(_, list([]), maybe.ok(reduced(list([]))), !Runtime).
-
-% Do a maybe-reduce on a list with a list as its head.
-preprocess(Pred, list(ElementsRaw @ [list(_)|_]), Result, !Runtime) :-
-    list.map_foldl3(Pred, ElementsRaw, Elements,
-        !Runtime,
-        0, ArgNum,
-        maybe.ok, ElementsError),
-    (
-        ElementsError = maybe.error(Error),
-        Result = maybe.error(Error)
-    ;
-        ElementsError = maybe.ok,
-        (
-            ( Elements = [] ; Elements = [list(_)|_] ),
-            Result = maybe.ok(reduced(list(Elements)))
-        ;
-            Elements = [atom(Tag)|Tail],
-            Result = maybe.ok(execute(Tag, Tail, ArgNum))
-        )
-    ).
-
-% Report a call for a list consisting of just an atom.
-preprocess(_, list([atom(Tag)|[]]), maybe.ok(execute(Tag, [], 0)), !Runtime).
-
-% Do a maybe-reduce on a list with an atom as its head.
-preprocess(Pred, In @ list([atom(Tag)|Tail]), Result, !Runtime) :-
-    Tail = [_|_],
-    ( if
-        Tag = "."
-    then
-        % Escaped list.
-        Result = maybe.ok(reduced(In))
-    else if
-        % Special handling for comparisons, since they must be laziy evaluated.
-        turbolisp.runtime.builtin.builtin_op_tag(Op, Tag),
-        turbolisp.runtime.builtin.comparison(Cmp) = Op
-    then
-        % Sort of punt on argument lists less than size 2.
-        % These will be errors later anyway.
-        (
-            Tail = [_|[]],
-            Result = maybe.ok(execute(Tag, Tail, 1))
-        ;
-            [E1|[E2|Tail2]] = Tail,
-            Pred(E1, R1, !Runtime, 0, _, maybe.ok, ResultMid),
-            Pred(E2, R2, !Runtime, 0, _, ResultMid, PredResult),
-            (
-                PredResult = maybe.ok,
-                Result = maybe.ok(comparison(Cmp, R1, R2, Tail2))
-            ;
-                PredResult = maybe.error(Error),
-                Result = maybe.error(Error)
-            )
-        )
-    else
-        list.map_foldl3(Pred, Tail, ReducedTail,
-            !Runtime,
-            0, ArgNum,
-            maybe.ok, ElementsError),
-        (
-            ElementsError = maybe.error(Error),
-            Result = maybe.error(Error)
-        ;
-            ElementsError = maybe.ok,
-            Result = maybe.ok(execute(Tag, ReducedTail, ArgNum))
-        )
-    ).
-
-%-----------------------------------------------------------------------------%
-
-:- pred is_atom(element).
-:- mode is_atom(in) is semidet.
-
-is_atom(atom(_)).
-
-%-----------------------------------------------------------------------------%
-
-:- pred is_atom_or_list_of_atoms(element).
-:- mode is_atom_or_list_of_atoms(in) is semidet.
-
-is_atom_or_list_of_atoms(atom(_)).
-is_atom_or_list_of_atoms(list([])).
-is_atom_or_list_of_atoms(list(List @ [_|_])) :- list.all_true(is_atom, List).
-
-%-----------------------------------------------------------------------------%
-% Reduces an element. This is mainly different in how it handles results from
-% binds, and how it handles comparisons.
-reduce(Element, Result, !Runtime) :-
-    preprocess(reduce, Element, PreprocessResult, !Runtime),
-    (
-        PreprocessResult = maybe.error(Error),
-        Result = maybe.error(Error)
-    ;
-        PreprocessResult = maybe.ok(PreprocessOutput),
-        (
-            PreprocessOutput = reduced(Reduced),
-            Result = maybe.ok(Reduced)
-        ;
-            PreprocessOutput = comparison(Cmp, A, B, Tail),
-            
-            % Try to inline the result of the comparison, if possible.
-            % This also allows us to not even compile the side which was not used.
-            turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
-            FallbackResult = maybe.ok(list([atom(Tag)|Tail])),
-            (
-                % Incorrect tail length for comparison builtin. Good luck kid.
-                ( Tail = [] ; Tail = [_|[]] ; Tail = [_|[_|[_|_]]] ),
-                Result = FallbackResult
-            ;
-                Tail = [Y|[N|[]]],
-                turbolisp.runtime.builtin.comparison(Cmp, A, B, CmpResult),
-                (
-                    CmpResult = turbolisp.runtime.builtin.error(_),
-                    Result = FallbackResult
-                ;
-                    (
-                        CmpResult = turbolisp.runtime.builtin.yes, Choice = Y
-                    ;
-                        CmpResult = turbolisp.runtime.builtin.no, Choice = N
-                    ),
-                    
-                    % It should be safe to reduce the result. EIther it is known at
-                    % compile-time, or the comparison will have failed to yield a
-                    % result and we won't be in this arm.
-                    reduce(Choice, ChoiceResult, !Runtime),
-                    (
-                        ChoiceResult = maybe.error(_),
-                        Result = FallbackResult
-                    ;
-                        ChoiceResult = maybe.ok(_),
-                        Result = ChoiceResult
-                    )
-                )
-            )
-        ;
-            PreprocessOutput = execute(Tag, Tail, Arity),
-            ( if
-                % Do NOT use the results of define ops during reduction.
-                % For let's, the existence of the let will be erased by popping
-                % the stack frame, and the value will not show up later in the
-                % actual execution.
-                % For fn's def's, this would erase the definition entirely as
-                % we may lose the entire runtime between reduction and
-                % execution (as in copmilation model).
-                % We can still retain the reduced tail, however.
-                % It is also useful to actually bind the value anyway, since
-                % this lets us inline functions and variables.
-                % See below for inlining determination.
-                turbolisp__runtime__builtin__builtin_op_tag(
-                    turbolisp__runtime__builtin__define(Op), Tag)
-            then
-                (
-                    Op = turbolisp.runtime.builtin.fn,
-                    % Super rudimentary inline test.
-                    % Only inline fn if we have a body consisting of less than
-                    % 64 elements, and all the elements are either atoms or a
-                    % list of atoms (as opposed to a list with list elements).
-                    ( if
-                        list.index0(Tail, 1, Body),
-                        (
-                            Body = atom(_)
-                        ;
-                            Body = list(List),
-                            builtin__compare((<), list.length(List), 64),
-                            list.all_true(is_atom_or_list_of_atoms, List)
-                        )
-                    then
-                        turbolisp.runtime.builtin.builtin_fn_bind(Tail, _, !Runtime)
-                    else
-                        true
-                    )
-                ;
-                    Op = turbolisp.runtime.builtin.let
-                ;
-                    Op = turbolisp.runtime.builtin.def
-                ),
-                Result = maybe.ok(list([atom(Tag)|Tail]))
-            else if
-                find_bind(Tag, Arity, !.Runtime ^ binds, Bind)
-            then
-                call_bind(Bind, Tail, CallResult, !Runtime),
-                
-                (
-                    CallResult = maybe.error(Error),
-                    Result = maybe.error(func_error(Tag, Arity, Error))
-                ;
-                    CallResult = maybe.ok(_),
-                    Result = CallResult
-                )
-            else
-                Result = maybe.ok(list([atom(Tag)|Tail]))
-            )
-        )
-    ).
-
-%-----------------------------------------------------------------------------%
-
-reduce(!E, !R, maybe.error(E), maybe.error(E)).
-reduce(In, Out, !Runtime, maybe.ok, Result) :-
-    reduce(In, OutResult, !Runtime),
-    (
-        OutResult = maybe.error(Error),
-        Result = maybe.error(Error),
-        In = Out
-    ;
-        OutResult = maybe.ok(Out),
-        Result = maybe.ok
-    ).
-
-%-----------------------------------------------------------------------------%
-
-reduce(!Element, !Runtime, N, int.plus(N, 1), !Error) :-
-    reduce(!Element, !Runtime, !Error).
-
-%-----------------------------------------------------------------------------%
-
-execute(Element, Result, !Runtime) :-
-    preprocess(reduce, Element, PreprocessResult, !Runtime),
-    (
-        PreprocessResult = maybe.error(Error),
-        Result = maybe.error(Error)
-    ;
-        PreprocessResult = maybe.ok(PreprocessOutput),
-        (
-            PreprocessOutput = reduced(list(ReducedList)),
-            % Remove escaping during execution.
-            ( if
-                ReducedList = [atom(".")|Tail]
-            then
-                Result = maybe.ok(list(Tail))
-            else
-                Result = maybe.ok(list(ReducedList))
-            )
-        ;
-            PreprocessOutput = reduced(atom(ReducedAtom)),
-            ( if
-                find_var(!.Runtime ^ stack_frames,
-                    !.Runtime ^ globals,
-                    ReducedAtom, SemiValue)
-            then
-                Result = maybe.ok(SemiValue)
-            else
-                Result = maybe.ok(atom(ReducedAtom))
-            )
-        ;
-            PreprocessOutput = comparison(Cmp, A, B, Tail),
-            
-            (
-                % Incorrect tail length for comparison builtin. Good luck kid.
-                ( Tail = [] ; Tail = [_|[]] ; Tail = [_|[_|[_|_]]] ),
-                turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
-                Result = maybe.error(func_error(Tag, 2, "Comparison must have arity of 2"))
-            ;
-                Tail = [Y|[N|[]]],
-                turbolisp.runtime.builtin.comparison(Cmp, A, B, CmpResult),
-                (
-                    CmpResult = turbolisp.runtime.builtin.error(Error),
-                    turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
-                    Result = maybe.error(func_error(Tag, 2, Error))
-                ;
-                    (
-                        CmpResult = turbolisp.runtime.builtin.yes, Choice = Y
-                    ;
-                        CmpResult = turbolisp.runtime.builtin.no, Choice = N
-                    ),
-                    
-                    % It should be safe to reduce the result. EIther it is known at
-                    % compile-time, or the comparison will have failed to yield a
-                    % result and we won't be in this arm.
-                    reduce(Choice, ChoiceResult, !Runtime),
-                    (
-                        ChoiceResult = maybe.error(Error),
-                        turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
-                        Result = maybe.error(func_error(Tag, 2, Error))
-                    ;
-                        ChoiceResult = maybe.ok(_),
-                        Result = ChoiceResult
-                    )
-                )
-            )
-        ;
-            PreprocessOutput = execute(Tag, Tail, Arity),
-            
-            ( if
-                find_bind(Tag, Arity, !.Runtime ^ binds, Bind)
-            then
-                call_bind(Bind, Tail, CallResult, !Runtime),
-                (
-                    CallResult = maybe.error(Error),
-                    Result = maybe.error(func_error(Tag, Arity, Error))
-                ;
-                    CallResult = maybe.ok(_),
-                    Result = CallResult
-                )
-            else
-                Result = maybe.ok(list([atom(Tag)|Tail]))
-            )
-        )
-    ).
-
-%-----------------------------------------------------------------------------%
-
-execute(!E, !R, maybe.error(E), maybe.error(E)).
-execute(In, Out, !Runtime, maybe.ok, Result) :-
-    execute(In, OutResult, !Runtime),
-    (
-        OutResult = maybe.error(Error),
-        Result = maybe.error(Error),
-        In = Out
-    ;
-        OutResult = maybe.ok(Out),
-        Result = maybe.ok
-    ).
-
-%-----------------------------------------------------------------------------%
-
-execute(!Element, !Runtime, N, int.plus(N, 1), !Error) :-
-    execute(!Element, !Runtime, !Error).
+% Copyright (c) 2019  AlaskanEmily, Transnat Games
+%
+% This Source Code Form is subject to the terms of the Mozilla Public
+% License, v. 2.0. If a copy of the MPL was not distributed with this
+% file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+:- module turbolisp.runtime.
+
+%=============================================================================%
+% TurboLisp runtime components.
+:- interface.
+%=============================================================================%
+
+:- import_module list.
+:- use_module assoc_list.
+:- use_module rbtree.
+:- use_module maybe.
+
+%-----------------------------------------------------------------------------%
+% TODO!
+:- func nil = element.
+
+%-----------------------------------------------------------------------------%
+% Frames use an assoc list, as they are not expected to have a lot of elements,
+% and the extra allocations of a tree would quickly overwhelm the gains in
+% lookup speed.
+:- type frame --->
+    frame(variables::assoc_list.assoc_list(string, element)).
+
+%-----------------------------------------------------------------------------%
+
+:- func init_frame = frame.
+
+%-----------------------------------------------------------------------------%
+
+:- func init_frame(assoc_list.assoc_list(string, element)) = frame.
+
+%-----------------------------------------------------------------------------%
+
+:- type result == maybe.maybe_error(element).
+
+%-----------------------------------------------------------------------------%
+
+:- inst maybe_unique_error --->
+    maybe.ok(ground) ;
+    maybe.error(unique).
+
+:- inst maybe_clobbered_error --->
+    maybe.ok(ground) ;
+    maybe.error(clobbered).
+
+:- mode res_uo == free >> maybe_unique_error.
+:- mode res_di == maybe_unique_error >> maybe_clobbered_error.
+
+%-----------------------------------------------------------------------------%
+
+:- type execute_pred == (pred(list.list(element), result, runtime, runtime)).
+:- inst execute_pred == (pred(in, res_uo, in, out) is det).
+:- mode execute_pred == (pred(in, res_uo, in, out) is det).
+
+:- type bind --->
+    mercury_bind(pred(list.list(element)::in, result::res_uo, runtime::in, runtime::out) is det) ;
+    lisp_bind(arg_names::list.list(string), body::list.list(element)).
+
+%-----------------------------------------------------------------------------%
+
+:- type bind_spec --->
+    variadic(string) ;
+    args(string, int).
+
+%-----------------------------------------------------------------------------%
+
+:- type variables == rbtree.rbtree(string, element).
+
+%-----------------------------------------------------------------------------%
+
+:- type runtime ---> runtime(
+    globals::variables,
+    binds::rbtree.rbtree(bind_spec, bind),
+    stack_frames::list.list(frame),
+    pending_io::list.list(string)).
+
+%-----------------------------------------------------------------------------%
+
+:- func init = runtime.
+
+%-----------------------------------------------------------------------------%
+
+:- pred push_stack_frame(runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred push_stack_frame(assoc_list.assoc_list(string, element)::in,
+    runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred pop_stack_frame(runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred push_stack_frame_check(int::out, runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred push_stack_frame_check(assoc_list.assoc_list(string, element)::in,
+    int::out, runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred pop_stack_frame_check(int::in, runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred def_var(string::in, element::in, runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred find_var(list.list(frame), rbtree.rbtree(string, element), string, element).
+:- mode find_var(in, in, in, out) is semidet.
+
+%-----------------------------------------------------------------------------%
+
+:- pred builtin_bind(bind_spec::in, bind::out) is semidet.
+
+%-----------------------------------------------------------------------------%
+
+:- pred def_bind(bind_spec::in, bind::in, runtime::in, runtime::out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- pred find_bind(string, int, rbtree.rbtree(bind_spec, bind), bind).
+:- mode find_bind(in, in, in, out) is semidet.
+
+%-----------------------------------------------------------------------------%
+% This is a workaround, as the Mercury compiler gets confused when disjuncting
+% on functors which contain predicates as elements in the functor.
+:- pred call_bind(bind, list.list(element), result, runtime, runtime).
+:- mode call_bind(in, in, res_uo, in, out) is det.
+
+%-----------------------------------------------------------------------------%
+
+:- type run_pred1 == (pred(element, result, runtime, runtime)).
+:- inst run_pred1 == (pred(in, res_uo, in, out) is det).
+:- mode run_pred1 == (pred(in, res_uo, in, out) is det).
+
+%-----------------------------------------------------------------------------%
+% Same as run_pred1, but is suitable for use with list.map_foldl2
+:- type run_pred2 == (pred(element, element,
+    runtime, runtime,
+    maybe.maybe_error, maybe.maybe_error)).
+:- inst run_pred2 == (pred(in, out, in, out, di, uo) is det).
+:- mode run_pred2 == (pred(in, out, in, out, di, uo) is det).
+
+%-----------------------------------------------------------------------------%
+% Same as run_pred1, but is suitable for use with list.map_foldl3 while
+% counting elements in the list.
+:- type run_pred3 == (pred(element, element,
+    runtime, runtime,
+    int, int,
+    maybe.maybe_error, maybe.maybe_error)).
+:- inst run_pred3 == (pred(in, out, in, out, in, out, di, uo) is det).
+:- mode run_pred3 == (pred(in, out, in, out, in, out, di, uo) is det).
+
+%-----------------------------------------------------------------------------%
+
+:- pred reduce `with_type` run_pred1 `with_inst` run_pred1.
+:- pred reduce `with_type` run_pred2 `with_inst` run_pred2.
+:- pred reduce `with_type` run_pred3 `with_inst` run_pred3.
+
+%-----------------------------------------------------------------------------%
+
+:- pred execute `with_type` run_pred1 `with_inst` run_pred1.
+:- pred execute `with_type` run_pred2 `with_inst` run_pred2.
+:- pred execute `with_type` run_pred3 `with_inst` run_pred3.
+
+%=============================================================================%
+:- implementation.
+%=============================================================================%
+
+:- use_module exception.
+:- use_module int.
+:- use_module string.
+:- use_module pair.
+
+:- include_module turbolisp.runtime.builtin.
+:- use_module turbolisp.runtime.builtin.
+
+%-----------------------------------------------------------------------------%
+
+nil = list([]).
+
+%-----------------------------------------------------------------------------%
+% Used for the optimized C routines.
+:- pragma foreign_decl("C", "
+#ifdef _MSC_VER
+
+#define TL_YIELD_ARITY(ARITY, DST, OUT) \\
+    _ltoa_s((ARITY), (OUT), 77, 10); \\
+    (OUT)[76] = 0; \\
+    const MR_Integer DST = strnlen_s((OUT), 77)
+
+#else
+
+#define TL_YIELD_ARITY(ARITY, DST, OUT) \\
+    const MR_Integer DST = sprintf((OUT), ""%i"", (ARITY))
+
+#endif
+
+#define TL_YIELD_FUNC_NAME(NAME, NAME_LEN, ARITY, END, OUT) do { \\
+    (OUT)[0] = '`'; \\
+    memcpy((OUT)+1, Name, (NAME_LEN)); \\
+    (OUT)[(NAME_LEN)+1] = '/'; \\
+    { \\
+        const MR_Integer arity_start = (NAME_LEN)+2; \\
+        TL_YIELD_ARITY((ARITY), ZZ_end, (OUT) + arity_start) + arity_start; \\
+        (OUT)[ZZ_end] = '`'; \\
+        (END) = ZZ_end+1; \\
+    } \\
+    \\
+}while(0)
+
+").
+
+%-----------------------------------------------------------------------------%
+
+:- func yield_func_name(string::in, int::in) = (string::uo) is det.
+yield_func_name(Name, Arity) = string.append(TickFuncArity, "`") :-
+    string.first_char(ArityString, ('/'), string.from_int(Arity)),
+    string.first_char(TickFuncName, ('`'), Name),
+    string.append(TickFuncName, ArityString, TickFuncArity).
+
+% Optimized C version.
+:- pragma foreign_proc("C", yield_func_name(Name::in, Arity::in) = (Out::uo),
+    [promise_pure, thread_safe, will_not_call_mercury, will_not_modify_trail,
+     does_not_affect_liveness, may_duplicate],
+    "
+    const MR_Integer name_len = strlen(Name);
+    MR_allocate_aligned_string_msg(Out, name_len + 80, MR_ALLOC_ID);
+    MR_Integer end;
+    TL_YIELD_FUNC_NAME(Name, name_len, Arity, end, Out);
+    Out[end] = 0;
+    ").
+
+%-----------------------------------------------------------------------------%
+
+:- func func_error(string::in, int::in, string::in) = (string::uo) is det.
+func_error(Name, Arity, Error) =
+    string.append(func_error_prefix(Name, Arity), Error).
+
+%-----------------------------------------------------------------------------%
+
+:- func func_error_prefix(string::in, int::in) = (string::uo) is det.
+func_error_prefix(Name, Arity) =
+    string.append(
+    string.append(
+        "Error ",
+        yield_func_name(Name, Arity)),
+        " -> ").
+
+% Optimized C version.
+:- pragma foreign_proc("C", func_error(Name::in, Arity::in, Error::in) = (Out::uo),
+    [promise_pure, thread_safe, will_not_call_mercury, will_not_modify_trail,
+     does_not_affect_liveness, may_duplicate],
+    "
+    const char head[] = {'E', 'r', 'r', 'o', 'r', ':', ' '};
+    const char tail[] = {' ', '-', '>', ' '};
+    const MR_Integer name_len = strlen(Name);
+    const MR_Integer error_len = strlen(Error);
+    MR_allocate_aligned_string_msg(Out, name_len + error_len + 90, MR_ALLOC_ID);
+    MR_Integer end;
+    memcpy(Out, head, sizeof(head));
+    TL_YIELD_FUNC_NAME(Name, name_len, Arity, end, Out+sizeof(head));
+    memcpy(Out+sizeof(head)+end, tail, sizeof(tail));
+    memcpy(Out+sizeof(head)+sizeof(tail)+end, Error, error_len+1);
+    ").
+
+%-----------------------------------------------------------------------------%
+
+:- func list_index_error(int::in, int::in) = (string::uo) is det.
+list_index_error(At, Length) = Result :-
+    string.append("`at` -> index of '", string.from_int(At), Err0),
+    string.append(Err0, "' out of bounds for list of length '", Err1),
+    string.append(Err1, string.from_int(Length), Err2),
+    string.append(Err2, "'", Result).
+
+% Optimized C version.
+:- pragma foreign_proc("C", list_index_error(At::in, Length::in) = (Out::uo),
+    [promise_pure, thread_safe, will_not_call_mercury, will_not_modify_trail,
+     does_not_affect_liveness, may_duplicate],
+    "
+        MR_allocate_aligned_string_msg(Out, 160, MR_ALLOC_ID);
+        snprintf(Out, 159,
+            ""`at` -> index of '%i' out of bounds for list of length '%i'"",
+            At, Length);
+        Out[159] = 0;
+    ").
+
+%-----------------------------------------------------------------------------%
+
+init_frame(Variables) = frame(Variables).
+init_frame = init_frame([]).
+
+%-----------------------------------------------------------------------------%
+
+init = runtime(rbtree.init, rbtree.init, [], []).
+
+%-----------------------------------------------------------------------------%
+
+push_stack_frame(Variables, runtime(G, B, Frames, PIO),
+    runtime(G, B, [init_frame(Variables)|Frames], PIO)).
+
+%-----------------------------------------------------------------------------%
+
+push_stack_frame(runtime(G, B, Frames, PIO),
+    runtime(G, B, [init_frame|Frames], PIO)).
+
+%-----------------------------------------------------------------------------%
+
+pop_stack_frame(runtime(G, B, [_Head|Frames], PIO),
+    runtime(G, B, Frames, PIO)) :-
+    % trace [io(!IO)] (
+    %     rbtree.keys(Head ^ variables, Keys),
+    %     io.write_string("Pop losing ", !IO),
+    %     io.write_int(list.length(Keys), !IO), io.nl(!IO),
+    %     list.foldl(
+    %         (pred(Str::in, I::di, O::uo) is semidet :-
+    %             io.write_string(Str, I, M), io.nl(M, O)),
+    %         Keys, !IO)
+    % ),
+    true.
+
+pop_stack_frame(runtime(_, _, [], _), _) :-
+    exception.throw(exception.software_error("Stack underflow")).
+
+%-----------------------------------------------------------------------------%
+
+push_stack_frame_check(Check, !Runtime) :-
+    push_stack_frame(!Runtime),
+    list.length(!.Runtime ^ stack_frames, Check).
+
+%-----------------------------------------------------------------------------%
+
+push_stack_frame_check(Variables, Check, !Runtime) :-
+    push_stack_frame(Variables, !Runtime),
+    list.length(!.Runtime ^ stack_frames, Check).
+
+%-----------------------------------------------------------------------------%
+
+pop_stack_frame_check(Check, !Runtime) :-
+    ( if
+        list.length(!.Runtime ^ stack_frames, Check)
+    then
+       pop_stack_frame(!Runtime)
+    else
+        exception.throw(exception.software_error("Stack mismatch"))
+    ).
+
+%-----------------------------------------------------------------------------%
+
+def_var(Name, Value, !Runtime) :-
+    !.Runtime ^ stack_frames = StackFrames,
+    (
+        StackFrames = [frame(In)|Tail],
+        
+        ( assoc_list.remove(In, Name, _, V) -> Out = V ; Out = In ),
+        
+        !Runtime ^ stack_frames := [frame([pair.pair(Name, Value)|Out])|Tail]
+    ;
+        StackFrames = [],
+        
+        !.Runtime ^ globals = In,
+        rbtree.set(Name, Value, In, Out),
+        !Runtime ^ globals := Out
+    ).
+
+%-----------------------------------------------------------------------------%
+
+find_var([], Globals, Name, Value) :- rbtree.search(Globals, Name, Value).
+find_var([frame(Head)|Tail], Globals, Name, Value) :-
+    ( if
+        assoc_list.search(Head, Name, SemiValue)
+    then
+        Value = SemiValue
+    else
+        find_var(Tail, Globals, Name, Value)
+    ).
+
+%-----------------------------------------------------------------------------%
+
+builtin_bind(args("=", 4), mercury_bind(turbolisp__runtime__builtin__builtin_eq_bind)).
+builtin_bind(args("!", 4), mercury_bind(turbolisp__runtime__builtin__builtin_ne_bind)).
+builtin_bind(args("<", 4), mercury_bind(turbolisp__runtime__builtin__builtin_lt_bind)).
+builtin_bind(args(">", 4), mercury_bind(turbolisp__runtime__builtin__builtin_gt_bind)).
+builtin_bind(args("<=", 4), mercury_bind(turbolisp__runtime__builtin__builtin_le_bind)).
+builtin_bind(args(">=", 4), mercury_bind(turbolisp__runtime__builtin__builtin_ge_bind)).
+
+builtin_bind(args("+", 2), mercury_bind(turbolisp__runtime__builtin__builtin_plus_bind)).
+builtin_bind(args("-", 2), mercury_bind(turbolisp__runtime__builtin__builtin_minus_bind)).
+builtin_bind(args("*", 2), mercury_bind(turbolisp__runtime__builtin__builtin_times_bind)).
+builtin_bind(args("/", 2), mercury_bind(turbolisp__runtime__builtin__builtin_divide_bind)).
+
+builtin_bind(args("fn", 3), mercury_bind(turbolisp__runtime__builtin__builtin_fn_bind)).
+
+%-----------------------------------------------------------------------------%
+
+def_bind(BindSpec, Bind, !Runtime) :-
+    Binds = !.Runtime ^ binds,
+    !Runtime ^ binds := rbtree.set(Binds, BindSpec, Bind).
+
+%-----------------------------------------------------------------------------%
+
+find_bind(Name, Arity, Tree, Out) :-
+    % Try for set args before trying for variadic args.
+    Args = args(Name, Arity), Variadic = variadic(Name),
+    ( if
+        rbtree.search(Tree, Args, Bind)
+    then
+        Out = Bind
+    else if
+        builtin_bind(Args, Bind)
+    then
+        Out = Bind
+    else if
+        rbtree.search(Tree, Variadic, Bind)
+    then
+        Out = Bind
+    else
+        builtin_bind(Variadic, Out)
+    ).
+
+%-----------------------------------------------------------------------------%
+
+call_bind(mercury_bind(Pred), Args, Result, !Runtime) :-
+    call(Pred, Args, Result:result, !Runtime).
+
+call_bind(lisp_bind(ArgNames, Body), Args, Result, !Runtime) :-
+    
+    assoc_list.from_corresponding_lists(ArgNames, Args, Variables),
+    
+    % This is needed both for a func call, and just to yield the reduced
+    % version of this list if it is not executable.
+    push_stack_frame_check(Variables, Check, !Runtime),
+    % trace [io(!IO)] ( io.write_string("Push stack from in call_bind\n", !IO) ),
+    
+    list.map_foldl2(execute, Body, Values, !Runtime, maybe.ok, CallResult),
+    
+    % trace [io(!IO)] ( io.write_string("Pop stack from in call_bind\n", !IO) ),
+    pop_stack_frame_check(Check, !Runtime),
+    
+    (
+        CallResult = maybe.ok,
+        ( if
+            list.last(Values, Last)
+        then
+            Result = maybe.ok(Last)
+        else
+            Result = maybe.ok(nil)
+        )
+    ;
+        CallResult = maybe.error(Error),
+        Result = maybe.error(Error)
+    ).
+
+%-----------------------------------------------------------------------------%
+% Result of preprocessing.
+% Comparison is a special case because of laziness.
+:- type preprocess_result --->
+    reduced(element) ; % Result is fully reduced.
+    execute(string, list(element), preprocess_arity::int) ; % Result is a call.
+    comparison(turbolisp.runtime.builtin.comparison, element, element, list(element)).
+
+%-----------------------------------------------------------------------------%
+% Performs preprocessing logic which is shared between reduce and execute.
+:- pred preprocess(run_pred3, element, maybe.maybe_error(preprocess_result), runtime, runtime).
+:- mode preprocess(run_pred3, in, res_uo, in, out) is det.
+
+% Pass atoms through unchanged.
+preprocess(_, atom(Str), maybe.ok(reduced(atom(Str))), !Runtime).
+
+% Empty list, nothing to do.
+preprocess(_, list([]), maybe.ok(reduced(list([]))), !Runtime).
+
+% Do a maybe-reduce on a list with a list as its head.
+preprocess(Pred, list(ElementsRaw @ [list(_)|_]), Result, !Runtime) :-
+    list.map_foldl3(Pred, ElementsRaw, Elements,
+        !Runtime,
+        0, ArgNum,
+        maybe.ok, ElementsError),
+    (
+        ElementsError = maybe.error(Error),
+        Result = maybe.error(Error)
+    ;
+        ElementsError = maybe.ok,
+        (
+            ( Elements = [] ; Elements = [list(_)|_] ),
+            Result = maybe.ok(reduced(list(Elements)))
+        ;
+            Elements = [atom(Tag)|Tail],
+            Result = maybe.ok(execute(Tag, Tail, ArgNum))
+        )
+    ).
+
+% Report a call for a list consisting of just an atom.
+preprocess(_, list([atom(Tag)|[]]), maybe.ok(execute(Tag, [], 0)), !Runtime).
+
+% Do a maybe-reduce on a list with an atom as its head.
+preprocess(Pred, In @ list([atom(Tag)|Tail]), Result, !Runtime) :-
+    Tail = [_|_],
+    ( if
+        Tag = "."
+    then
+        % Escaped list.
+        Result = maybe.ok(reduced(In))
+    else if
+        % Special handling for comparisons, since they must be laziy evaluated.
+        turbolisp.runtime.builtin.builtin_op_tag(Op, Tag),
+        turbolisp.runtime.builtin.comparison(Cmp) = Op
+    then
+        % Sort of punt on argument lists less than size 2.
+        % These will be errors later anyway.
+        (
+            Tail = [_|[]],
+            Result = maybe.ok(execute(Tag, Tail, 1))
+        ;
+            [E1|[E2|Tail2]] = Tail,
+            Pred(E1, R1, !Runtime, 0, _, maybe.ok, ResultMid),
+            Pred(E2, R2, !Runtime, 0, _, ResultMid, PredResult),
+            (
+                PredResult = maybe.ok,
+                Result = maybe.ok(comparison(Cmp, R1, R2, Tail2))
+            ;
+                PredResult = maybe.error(Error),
+                Result = maybe.error(Error)
+            )
+        )
+    else
+        list.map_foldl3(Pred, Tail, ReducedTail,
+            !Runtime,
+            0, ArgNum,
+            maybe.ok, ElementsError),
+        (
+            ElementsError = maybe.error(Error),
+            Result = maybe.error(Error)
+        ;
+            ElementsError = maybe.ok,
+            Result = maybe.ok(execute(Tag, ReducedTail, ArgNum))
+        )
+    ).
+
+%-----------------------------------------------------------------------------%
+
+:- pred is_atom(element).
+:- mode is_atom(in) is semidet.
+
+is_atom(atom(_)).
+
+%-----------------------------------------------------------------------------%
+
+:- pred is_atom_or_list_of_atoms(element).
+:- mode is_atom_or_list_of_atoms(in) is semidet.
+
+is_atom_or_list_of_atoms(atom(_)).
+is_atom_or_list_of_atoms(list([])).
+is_atom_or_list_of_atoms(list(List @ [_|_])) :- list.all_true(is_atom, List).
+
+%-----------------------------------------------------------------------------%
+% Reduces an element. This is mainly different in how it handles results from
+% binds, and how it handles comparisons.
+reduce(Element, Result, !Runtime) :-
+    preprocess(reduce, Element, PreprocessResult, !Runtime),
+    (
+        PreprocessResult = maybe.error(Error),
+        Result = maybe.error(Error)
+    ;
+        PreprocessResult = maybe.ok(PreprocessOutput),
+        (
+            PreprocessOutput = reduced(Reduced),
+            Result = maybe.ok(Reduced)
+        ;
+            PreprocessOutput = comparison(Cmp, A, B, Tail),
+            
+            % Try to inline the result of the comparison, if possible.
+            % This also allows us to not even compile the side which was not used.
+            turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
+            FallbackResult = maybe.ok(list([atom(Tag)|Tail])),
+            (
+                % Incorrect tail length for comparison builtin. Good luck kid.
+                ( Tail = [] ; Tail = [_|[]] ; Tail = [_|[_|[_|_]]] ),
+                Result = FallbackResult
+            ;
+                Tail = [Y|[N|[]]],
+                turbolisp.runtime.builtin.comparison(Cmp, A, B, CmpResult),
+                (
+                    CmpResult = turbolisp.runtime.builtin.error(_),
+                    Result = FallbackResult
+                ;
+                    (
+                        CmpResult = turbolisp.runtime.builtin.yes, Choice = Y
+                    ;
+                        CmpResult = turbolisp.runtime.builtin.no, Choice = N
+                    ),
+                    
+                    % It should be safe to reduce the result. EIther it is known at
+                    % compile-time, or the comparison will have failed to yield a
+                    % result and we won't be in this arm.
+                    reduce(Choice, ChoiceResult, !Runtime),
+                    (
+                        ChoiceResult = maybe.error(_),
+                        Result = FallbackResult
+                    ;
+                        ChoiceResult = maybe.ok(_),
+                        Result = ChoiceResult
+                    )
+                )
+            )
+        ;
+            PreprocessOutput = execute(Tag, Tail, Arity),
+            ( if
+                % Do NOT use the results of define ops during reduction.
+                % For let's, the existence of the let will be erased by popping
+                % the stack frame, and the value will not show up later in the
+                % actual execution.
+                % For fn's def's, this would erase the definition entirely as
+                % we may lose the entire runtime between reduction and
+                % execution (as in copmilation model).
+                % We can still retain the reduced tail, however.
+                % It is also useful to actually bind the value anyway, since
+                % this lets us inline functions and variables.
+                % See below for inlining determination.
+                turbolisp__runtime__builtin__builtin_op_tag(
+                    turbolisp__runtime__builtin__define(Op), Tag)
+            then
+                (
+                    Op = turbolisp.runtime.builtin.fn,
+                    % Super rudimentary inline test.
+                    % Only inline fn if we have a body consisting of less than
+                    % 64 elements, and all the elements are either atoms or a
+                    % list of atoms (as opposed to a list with list elements).
+                    ( if
+                        list.index0(Tail, 1, Body),
+                        (
+                            Body = atom(_)
+                        ;
+                            Body = list(List),
+                            builtin__compare((<), list.length(List), 64),
+                            list.all_true(is_atom_or_list_of_atoms, List)
+                        )
+                    then
+                        turbolisp.runtime.builtin.builtin_fn_bind(Tail, _, !Runtime)
+                    else
+                        true
+                    )
+                ;
+                    Op = turbolisp.runtime.builtin.let
+                ;
+                    Op = turbolisp.runtime.builtin.def
+                ),
+                Result = maybe.ok(list([atom(Tag)|Tail]))
+            else if
+                find_bind(Tag, Arity, !.Runtime ^ binds, Bind)
+            then
+                call_bind(Bind, Tail, CallResult, !Runtime),
+                
+                (
+                    CallResult = maybe.error(Error),
+                    Result = maybe.error(func_error(Tag, Arity, Error))
+                ;
+                    CallResult = maybe.ok(_),
+                    Result = CallResult
+                )
+            else
+                Result = maybe.ok(list([atom(Tag)|Tail]))
+            )
+        )
+    ).
+
+%-----------------------------------------------------------------------------%
+
+reduce(!E, !R, maybe.error(E), maybe.error(E)).
+reduce(In, Out, !Runtime, maybe.ok, Result) :-
+    reduce(In, OutResult, !Runtime),
+    (
+        OutResult = maybe.error(Error),
+        Result = maybe.error(Error),
+        In = Out
+    ;
+        OutResult = maybe.ok(Out),
+        Result = maybe.ok
+    ).
+
+%-----------------------------------------------------------------------------%
+
+reduce(!Element, !Runtime, N, int.plus(N, 1), !Error) :-
+    reduce(!Element, !Runtime, !Error).
+
+%-----------------------------------------------------------------------------%
+
+execute(Element, Result, !Runtime) :-
+    preprocess(reduce, Element, PreprocessResult, !Runtime),
+    (
+        PreprocessResult = maybe.error(Error),
+        Result = maybe.error(Error)
+    ;
+        PreprocessResult = maybe.ok(PreprocessOutput),
+        (
+            PreprocessOutput = reduced(list(ReducedList)),
+            % Remove escaping during execution.
+            ( if
+                ReducedList = [atom(".")|Tail]
+            then
+                Result = maybe.ok(list(Tail))
+            else
+                Result = maybe.ok(list(ReducedList))
+            )
+        ;
+            PreprocessOutput = reduced(atom(ReducedAtom)),
+            ( if
+                find_var(!.Runtime ^ stack_frames,
+                    !.Runtime ^ globals,
+                    ReducedAtom, SemiValue)
+            then
+                Result = maybe.ok(SemiValue)
+            else
+                Result = maybe.ok(atom(ReducedAtom))
+            )
+        ;
+            PreprocessOutput = comparison(Cmp, A, B, Tail),
+            
+            (
+                % Incorrect tail length for comparison builtin. Good luck kid.
+                ( Tail = [] ; Tail = [_|[]] ; Tail = [_|[_|[_|_]]] ),
+                turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
+                Result = maybe.error(func_error(Tag, 2, "Comparison must have arity of 2"))
+            ;
+                Tail = [Y|[N|[]]],
+                turbolisp.runtime.builtin.comparison(Cmp, A, B, CmpResult),
+                (
+                    CmpResult = turbolisp.runtime.builtin.error(Error),
+                    turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
+                    Result = maybe.error(func_error(Tag, 2, Error))
+                ;
+                    (
+                        CmpResult = turbolisp.runtime.builtin.yes, Choice = Y
+                    ;
+                        CmpResult = turbolisp.runtime.builtin.no, Choice = N
+                    ),
+                    
+                    % It should be safe to reduce the result. EIther it is known at
+                    % compile-time, or the comparison will have failed to yield a
+                    % result and we won't be in this arm.
+                    reduce(Choice, ChoiceResult, !Runtime),
+                    (
+                        ChoiceResult = maybe.error(Error),
+                        turbolisp.runtime.builtin.comparison_tag(Cmp, Tag),
+                        Result = maybe.error(func_error(Tag, 2, Error))
+                    ;
+                        ChoiceResult = maybe.ok(_),
+                        Result = ChoiceResult
+                    )
+                )
+            )
+        ;
+            PreprocessOutput = execute(Tag, Tail, Arity),
+            
+            ( if
+                find_bind(Tag, Arity, !.Runtime ^ binds, Bind)
+            then
+                call_bind(Bind, Tail, CallResult, !Runtime),
+                (
+                    CallResult = maybe.error(Error),
+                    Result = maybe.error(func_error(Tag, Arity, Error))
+                ;
+                    CallResult = maybe.ok(_),
+                    Result = CallResult
+                )
+            else
+                Result = maybe.ok(list([atom(Tag)|Tail]))
+            )
+        )
+    ).
+
+%-----------------------------------------------------------------------------%
+
+execute(!E, !R, maybe.error(E), maybe.error(E)).
+execute(In, Out, !Runtime, maybe.ok, Result) :-
+    execute(In, OutResult, !Runtime),
+    (
+        OutResult = maybe.error(Error),
+        Result = maybe.error(Error),
+        In = Out
+    ;
+        OutResult = maybe.ok(Out),
+        Result = maybe.ok
+    ).
+
+%-----------------------------------------------------------------------------%
+
+execute(!Element, !Runtime, N, int.plus(N, 1), !Error) :-
+    execute(!Element, !Runtime, !Error).