From 8a222087c6655180532267ee487a05a7ae6cfc4a Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 5 May 2015 15:48:31 -0600 Subject: [PATCH 01/46] start of work on new vm, for a simple count-up we're still as efficient as the old code --- Makefile | 6 + pixie/compiler.pxi | 243 ++++++++++ pixie/stdlib.pxi | 1 + pixie/vm2/__init__.py | 1 + pixie/vm2/array.py | 239 ++++++++++ pixie/vm2/code.py | 993 +++++++++++++++++++++++++++++++++++++++ pixie/vm2/interpreter.py | 191 ++++++++ pixie/vm2/keyword.py | 81 ++++ pixie/vm2/numbers.py | 431 +++++++++++++++++ pixie/vm2/object.py | 161 +++++++ pixie/vm2/primitives.py | 25 + pixie/vm2/rt.py | 170 +++++++ pixie/vm2/string.py | 154 ++++++ target2.py | 125 +++++ 14 files changed, 2821 insertions(+) create mode 100644 pixie/compiler.pxi create mode 100644 pixie/vm2/__init__.py create mode 100644 pixie/vm2/array.py create mode 100644 pixie/vm2/code.py create mode 100644 pixie/vm2/interpreter.py create mode 100644 pixie/vm2/keyword.py create mode 100644 pixie/vm2/numbers.py create mode 100644 pixie/vm2/object.py create mode 100644 pixie/vm2/primitives.py create mode 100644 pixie/vm2/rt.py create mode 100644 pixie/vm2/string.py create mode 100644 target2.py diff --git a/Makefile b/Makefile index 5829c583..74bdf302 100644 --- a/Makefile +++ b/Makefile @@ -22,6 +22,9 @@ build_with_jit: fetch_externals $(PYTHON) $(EXTERNALS)/pypy/rpython/bin/rpython $(COMMON_BUILD_OPTS) --opt=jit target.py make compile_basics +build_with_jit2: fetch_externals + $(PYTHON) $(EXTERNALS)/pypy/rpython/bin/rpython $(COMMON_BUILD_OPTS) --opt=jit target2.py + build_no_jit: fetch_externals $(PYTHON) $(EXTERNALS)/pypy/rpython/bin/rpython $(COMMON_BUILD_OPTS) target.py make compile_basics @@ -62,6 +65,9 @@ run: run_interactive: @PYTHONPATH=$(PYTHONPATH) $(PYTHON) target.py +run_interactive2: + @PYTHONPATH=$(PYTHONPATH) pypy target2.py + run_interactive_stacklets: @PYTHONPATH=$(PYTHONPATH) $(PYTHON) target.py pixie/stacklets.pxi diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi new file mode 100644 index 00000000..a6afec3f --- /dev/null +++ b/pixie/compiler.pxi @@ -0,0 +1,243 @@ +(ns pixie.compiler) + +(def *env* nil) +(set-dynamic! (var *env*)) + +(defmulti analyze-form (fn [x] + (cond + (nil? x) nil + (seq? x) :seq + (vector? x) :vector + (symbol? x) :symbol + (number? x) :number))) + +(defmulti analyze-seq (fn [x] + (let [f (first x)] + (if (symbol? f) + f + :invoke)))) + + +;; Special Forms + +(defmethod analyze-seq 'do + [x] + {:op :do + :children '[:statements :ret] + :env *env* + :form x + :statements (mapv analyze-form (butlast (next x))) + :ret (analyze-form (last x))}) + +(defmethod analyze-seq 'if + [[_ test then else :as form]] + {:op :if + :children '[:test :then :else] + :env *env* + :form form + :test (analyze-form test) + :then (analyze-form then) + :else (analyze-form else)}) + + +(defmethod analyze-seq 'fn* + [[_ & body :as form]] + (let [[name body] (if (symbol? (first body)) + [(first body) + (next body)] + [(gensym "fn_") + body]) + arities (if (vector? (first body)) + [body] + body) + analyzed-bodies (reduce + analyze-fn-body + {} + arities)] + {:op :fn + :env *env* + :form form + :name name + :children '[:arities] + :arities (vals analyzed-bodies)} + )) + +(defn analyze-fn-body [acc [args & body]] + ; TODO: Add support for variadic fns + (let [arity (count args) + new-env (reduce + (fn [acc idx] + (let [arg-name (nth args idx)] + (assoc-in acc [:locals arg-name] {:op :binding + :type :arg + :idx idx + :name arg-name + :form arg-name + :env *env*}))) + *env* + (range (count args)))] + (assert (not (acc arity)) (str "Duplicate arity for " (cons args body))) + (assoc acc arity {:op :fn-body + :env *env* + :arity arity + :args args + :children '[:body] + :body (binding [*env* new-env] + (analyze-form (cons 'do body)))}))) + + +(defmethod analyze-seq 'let* + [[_ bindings & body :as form]] + (assert (even? (count bindings)) "Let requires an even number of bindings") + (let [parted (partition 2 bindings) + [new-env bindings] (reduce + (fn [[new-env bindings] [name binding-form]] + (let [binding-ast (binding [*env* new-env] + {:op :binding + :type :let + :children [:value] + :form binding-form + :env *env* + :name name + :value (analyze-form binding-form)})] + [(assoc-in new-env [:locals name] binding-ast) + (conj bindings binding-ast)])) + [*env* []] + parted)] + {:op :let + :form form + :children [:bindings :body] + :bindings bindings + :env *env* + :body (binding [*env* new-env] + (analyze-form `(do ~@body)))})) + +(defmethod analyze-seq 'def + [[_ nm val :as form]] + {:op :def + :name nm + :form form + :env *env* + :children [:val] + :val (analyze-form val)}) + +(defmethod analyze-form nil + [_] + {:op :const + :env *env* + :form nil}) + +(defmethod analyze-seq :default + [[sym & args :as form]] + (println form) + (let [resolved (resolve-in (the-ns (:ns *env*)) sym)] + (if (and resolved + (macro? @resolved)) + (analyze-form (apply @resolved args)) + {:op :invoke + :children '[:fn :args] + :form form + :env *env* + :fn (analyze-form sym) + :args (mapv analyze-form args)}))) + + +(defmethod analyze-form :number + [x] + {:op :const + :form x + :env *env*}) + +(defmethod analyze-form :seq + [x] + (analyze-seq x)) + +(defmethod analyze-form :symbol + [x] + (if-let [local (get-in *env* [:locals x])] + local + {:op :global + :env *env* + :form x})) + + +;; ENV Functions + +(defn new-env + "Creates a new (empty) environment" + [] + {:ns 'user}) + + +(defn analyze [form] + (binding [*env* (new-env)] + (analyze-form form))) + + + + + +(defn walk [post pre selector node] + (-> (reduce + (fn [node k] + (let [v (get node k) + result (if (or (vector? v) + (seq? v)) + (mapv (partial walk post pre selector) v) + (walk post pre selector v))] + (assoc node k result))) + (pre node) + (selector node)) + post)) + + +(defn remove-env [ast] + (walk #(dissoc % :env) + identity + :children + ast)) + +(let [form '((fn this [i max] + (if (-lt i max) + (this (-add i 1) + max) + i)) + 1000)] + (println (string-builder @(to-rpython (atom (string-builder)) 0 (remove-env (analyze form)))))) + +(defn write! [sb val] + (swap! sb conj! val) + sb) + +(defn offset-spaces [sb off] + (dotimes [x off] + (write! sb " "))) + +(defmulti to-rpython (fn [sb offset node] + (:op node))) + +(defmethod to-rpython :if + [sb offset {:keys [test then else]}] + #_(offset-spaces sb offset) + (write! sb "i.If(\n") + (let [offset (inc offset)] + (doseq [[nm form] [[:test test] + [:then then] + [:else else]]] + (offset-spaces sb offset) + (write! sb (name nm)) + (write! sb "=") + (to-rpython sb offset form) + (write! sb ",\n")) + (offset-spaces sb offset) + (write! sb ")"))) + +(defmethod to-rpython :const + [sb offset {:keys [form]}] + (write! sb "i.Const(rt.wrap(") + (write! sb (str form)) + (write! sb "))")) + + + +(defmethod rpython-node) diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index 6f260ade..bd8011ac 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -1816,6 +1816,7 @@ For more information, see http://clojure.org/special_forms#binding-forms"} (and (< step 0) (> start stop))) (cons start (lazy-seq* #(range (+ start step) stop step)))))) + (extend -str Range (fn [v] (-str (seq v)))) diff --git a/pixie/vm2/__init__.py b/pixie/vm2/__init__.py new file mode 100644 index 00000000..f87606f0 --- /dev/null +++ b/pixie/vm2/__init__.py @@ -0,0 +1 @@ +__author__ = 'tim' diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py new file mode 100644 index 00000000..50ac931c --- /dev/null +++ b/pixie/vm2/array.py @@ -0,0 +1,239 @@ +import pixie.vm2.rt as rt +import pixie.vm2.object as object +from pixie.vm2.object import affirm +from pixie.vm2.code import extend, as_var +from pixie.vm2.numbers import Integer +from pixie.vm2.primitives import nil +#import pixie.vm.stdlib as proto +import rpython.rlib.jit as jit +from rpython.rtyper.lltypesystem import lltype +from rpython.rlib.rarithmetic import intmask + +UNROLL_IF_SMALLER_THAN = 8 + +class Array(object.Object): + _type = object.Type(u"pixie.stdlib.Array") + _immutable_fields_ = ["_list"] + def type(self): + return Array._type + + def __init__(self, lst): + self._list = lst + + @jit.unroll_safe + def reduce_small(self, f, init): + for x in range(len(self._list)): + if rt.reduced_QMARK_(init): + return rt.deref(init) + init = f.invoke([init, self._list[x]]) + return init + + + def reduce_large(self, f, init): + for x in range(len(self._list)): + if rt.reduced_QMARK_(init): + return rt.deref(init) + init = f.invoke([init, self._list[x]]) + return init +# +# +# @extend(proto._count, Array) +# def _count(self): +# assert isinstance(self, Array) +# return rt.wrap(len(self._list)) +# +# @extend(proto._nth, Array) +# def _nth(self, idx): +# assert isinstance(self, Array) +# ival = idx.int_val() +# if ival < len(self._list): +# return self._list[ival] +# else: +# affirm(False, u"Index out of Range") +# +# @extend(proto._nth_not_found, Array) +# def _nth_not_found(self, idx, not_found): +# assert isinstance(self, Array) +# ival = idx.int_val() +# if ival < len(self._list): +# return self._list[ival] +# else: +# return not_found +# +# @extend(proto._reduce, Array) +# def reduce(self, f, init): +# assert isinstance(self, Array) +# if len(self._list) > UNROLL_IF_SMALLER_THAN: +# return self.reduce_large(f, init) +# return self.reduce_small(f, init) +# +# @extend(proto._seq, Array) +# def _seq(self): +# assert isinstance(self, Array) +# if rt.count(self) > 0: +# return ArraySeq(0, self) +# else: +# return nil +# +# class ArraySeq(object.Object): +# _type = object.Type(u"pixie.stdlib.ArraySeq") +# _immutable_fields_ = ["_idx", "_w_array"] +# +# def __init__(self, idx, array): +# self._idx = idx +# self._w_array = array +# +# def first(self): +# return rt.nth(self._w_array, rt.wrap(self._idx)) +# +# def next(self): +# if self._idx < rt.count(self._w_array) - 1: +# return ArraySeq(self._idx + 1, self._w_array) +# else: +# return nil +# +# def reduce(self, f, init): +# for x in range(self._idx, rt.count(self._w_array)): +# if rt.reduced_QMARK_(init): +# return rt.deref(init) +# init = f.invoke([init, rt.nth(self._w_array, rt.wrap(x))]) +# return init +# +# def type(self): +# return self._type +# # +# @extend(proto._first, ArraySeq) +# def _first(self): +# assert isinstance(self, ArraySeq) +# return self.first() +# +# @extend(proto._next, ArraySeq) +# def _next(self): +# assert isinstance(self, ArraySeq) +# return self.next() +# +# @extend(proto._seq, ArraySeq) +# def _seq(self): +# assert isinstance(self, ArraySeq) +# return self +# +# @extend(proto._reduce, ArraySeq) +# def _reduce(self, f, init): +# assert isinstance(self, ArraySeq) +# return self.reduce(f, init) +# +# def array(lst): +# assert isinstance(lst, list) +# return Array(lst) +# +# @as_var("aget") +# def aget(self, idx): +# assert isinstance(self, Array) +# return self._list[idx.int_val()] +# +# @as_var("aset") +# def aset(self, idx, val): +# assert isinstance(self, Array) +# self._list[idx.int_val()] = val +# return val +# +# @as_var("aslice") +# def aslice(self, offset): +# assert isinstance(self, Array) and isinstance(offset, Integer) +# +# offset = offset.int_val() +# if offset >= 0: +# return Array(self._list[offset:]) +# else: +# rt.throw(rt.wrap(u"offset must be an Integer >= 0")) +# +# @as_var("aconcat") +# def aconcat(self, other): +# assert isinstance(self, Array) and isinstance(other, Array) +# return Array(self._list + other._list) +# +# @as_var("alength") +# def alength(self): +# assert isinstance(self, Array) +# return rt.wrap(len(self._list)) +# +# @as_var("make-array") +# def make_array(l): +# affirm(isinstance(l, Integer), u"l must be an Integer") +# return Array([nil] * l.int_val()) +# +# +# # ByteArray +# ARRAY_OF_UCHAR = lltype.Array(lltype.Char) +# +# class ByteArray(object.Object): +# _type = object.Type(u"pixie.stdlib.ByteArray") +# +# def __init__(self, size): +# self._cnt = size +# self._buffer = lltype.malloc(ARRAY_OF_UCHAR, size, flavor="raw") +# for x in range(size): +# self._buffer[x] = chr(0) +# +# def type(self): +# return ByteArray._type +# +# +# def __del__(self): +# lltype.free(self._buffer, flavor="raw") +# +# +# @jit.unroll_safe +# def reduce_small(self, f, init): +# for x in range(self._cnt): +# if rt.reduced_QMARK_(init): +# return rt.deref(init) +# init = f.invoke([init, rt.wrap(ord(self._buffer[x]))]) +# return init +# +# +# def reduce_large(self, f, init): +# for x in range(self._cnt): +# if rt.reduced_QMARK_(init): +# return rt.deref(init) +# init = f.invoke([init, rt.wrap(ord(self._buffer[x]))]) +# return init +# +# +# @as_var("byte-array") +# def _byte_array(size): +# assert isinstance(size, Integer) +# v = size.r_uint_val() +# return ByteArray(v) +# +# @extend(proto._reduce, ByteArray) +# def _reduce(self, f, init): +# assert isinstance(self, ByteArray) +# if self._cnt > UNROLL_IF_SMALLER_THAN: +# return self.reduce_large(f, init) +# return self.reduce_small(f, init) +# +# @extend(proto._nth, ByteArray) +# def _nth(self, idx): +# assert isinstance(self, ByteArray) +# affirm(isinstance(idx, Integer), u"Index must be an integer") +# ival = idx.r_uint_val() +# if 0 <= ival < self._cnt: +# return rt.wrap(ord(self._buffer[ival])) +# +# return affirm(False, u"Index out of Range") +# +# @extend(proto._nth_not_found, ByteArray) +# def _nth_not_found(self, idx, not_found): +# assert isinstance(self, ByteArray) +# affirm(isinstance(idx, Integer), u"Index must be an integer") +# ival = idx.r_uint_val() +# if 0 <= ival < self._cnt: +# return rt.wrap(ord(self._buffer[ival])) +# +# return not_found +# +# @extend(proto._count, ByteArray) +# def _count(self): +# assert isinstance(self, ByteArray) +# return rt.wrap(intmask(self._cnt)) diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py new file mode 100644 index 00000000..0d9801d3 --- /dev/null +++ b/pixie/vm2/code.py @@ -0,0 +1,993 @@ +py_object = object +import pixie.vm2.object as object +from pixie.vm2.object import affirm, runtime_error +from pixie.vm2.primitives import nil, false +from rpython.rlib.rarithmetic import r_uint +from rpython.rlib.listsort import TimSort +from rpython.rlib.jit import elidable_promote, promote +from rpython.rlib.objectmodel import we_are_translated +import rpython.rlib.jit as jit +import pixie.vm2.rt as rt + + +BYTECODES = ["LOAD_CONST", + "ADD", + "EQ", + "INVOKE", + "TAIL_CALL", + "DUP_NTH", + "RETURN", + "COND_BR", + "JMP", + "CLOSED_OVER", + "MAKE_CLOSURE", + "SET_VAR", + "POP", + "DEREF_VAR", + "INSTALL", + "LOOP_RECUR", + "ARG", + "PUSH_SELF", + "POP_UP_N", + "MAKE_MULTI_ARITY", + "MAKE_VARIADIC", + "YIELD", + "PUSH_NS"] + +for x in range(len(BYTECODES)): + globals()[BYTECODES[x]] = r_uint(x) + + +@jit.unroll_safe +def resize_list(lst, new_size): + """'Resizes' a list, via reallocation and copy""" + affirm(len(lst) < new_size, u"New list must be larger than old list") + new_list = [None] * new_size + i = r_uint(0) + while i < len(lst): + new_list[i] = lst[i] + i += 1 + return new_list + + +@jit.unroll_safe +def list_copy(from_lst, from_loc, to_list, to_loc, count): + from_loc = r_uint(from_loc) + to_loc = r_uint(to_loc) + count = r_uint(count) + + i = r_uint(0) + while i < count: + to_list[to_loc + i] = from_lst[from_loc + i] + i += 1 + return to_list + + +@jit.unroll_safe +def slice_to_end(from_list, start_pos): + start_pos = r_uint(start_pos) + items_to_copy = len(from_list) - start_pos + new_lst = [None] * items_to_copy + list_copy(from_list, start_pos, new_lst, 0, items_to_copy) + return new_lst + + +@jit.unroll_safe +def slice_from_start(from_list, count, extra=r_uint(0)): + new_lst = [None] * (count + extra) + list_copy(from_list, 0, new_lst, 0, count) + return new_lst + + +# class TailCall(object.Object): +# _type = object.Type("TailCall") +# __immutable_fields_ = ["_f", "_args"] +# def __init__(self, f, args): +# self._f = f +# self._args = args +# +# def run(self): +# return self._f._invoke(self._args) + + +class BaseCode(object.Object): + _immutable_fields_ = ["_meta"] + def __init__(self): + assert isinstance(self, BaseCode) + self._name = u"unknown" + self._is_macro = False + self._meta = nil + + def meta(self): + return self._meta + + def with_meta(self, meta): + assert false, "not implemented" + + def name(self): + return self._name + + def set_macro(self): + self._is_macro = True + + def is_macro(self): + assert isinstance(self, BaseCode) + return self._is_macro + + def get_consts(self): + raise NotImplementedError() + + def get_bytecode(self): + raise NotImplementedError() + + @elidable_promote() + def stack_size(self): + return 0 + + def invoke_with(self, args, this_fn): + return self.invoke(args) + +def join_last(words, sep): + """ + Joins by commas and uses 'sep' on last word. + + Eg. join_last(['dog', 'cat', 'rat'] , 'and') = 'dog, cat and rat' + """ + if len(words) == 1: + return words[0] + else: + if len(words) == 2: + s = words[0] + u" " + sep + u" " + words[1] + else: + s = u", ".join(words[0:-1]) + s += u" " + sep + u" " + words[-1] + return s + +class MultiArityFn(BaseCode): + _type = object.Type(u"pixie.stdlib.MultiArityFn") + + _immutable_fields_ = ["_arities[*]", "_required_arity", "_rest_fn"] + + def type(self): + return MultiArityFn._type + + def __init__(self, name, arities, required_arity=0, rest_fn=None, meta=nil): + BaseCode.__init__(self) + self._name = name + self._arities = arities + self._required_arity = required_arity + self._rest_fn = rest_fn + self._meta = meta + + def with_meta(self, meta): + return MultiArityFn(self._name, self._arities, self._required_arity, self._rest_fn, meta) + + @elidable_promote() + def get_fn(self, arity): + f = self._arities.get(arity, None) + if f is not None: + return f + if self._rest_fn is not None and arity >= self._required_arity: + return self._rest_fn + + acc = [] + sorted = TimSort(self.get_arities()) + sorted.sort() + for x in sorted.list: + acc.append(unicode(str(x))) + + if self._rest_fn: + acc.append(unicode(str(self._rest_fn.required_arity())) + u"+") + + runtime_error(u"Wrong number of arguments " + unicode(str(arity)) + u" for function '" + unicode(self._name) + u"'. Expected " + join_last(acc, u"or"), + u"pixie.stdlib/InvalidArityException") + + def get_arities(self): + return self._arities.keys() + + def invoke(self, args): + return self.invoke_with(args, self) + + def invoke_with(self, args, self_fn): + return self.get_fn(len(args)).invoke_with(args, self_fn) + + +class NativeFn(BaseCode): + """Wrapper for a native function""" + _type = object.Type(u"pixie.stdlib.NativeFn") + + def __init__(self, doc=None): + BaseCode.__init__(self) + + def type(self): + return NativeFn._type + + def invoke(self, args): + return self.inner_invoke(args) + + def invoke_k(self, args, stack): + return self.invoke(args), stack + + def inner_invoke(self, args): + raise NotImplementedError() + + def invoke_with(self, args, this_fn): + return self.invoke(args) + + +class Code(BaseCode): + """Interpreted code block. Contains consts and """ + _type = object.Type(u"pixie.stdlib.Code") + _immutable_fields_ = ["_arity", "_consts[*]", "_bytecode", "_stack_size", "_meta"] + + def type(self): + return Code._type + + def __init__(self, name, arity, bytecode, consts, stack_size, debug_points, meta=nil): + BaseCode.__init__(self) + self._arity = arity + self._bytecode = bytecode + self._consts = consts + self._name = name + self._stack_size = stack_size + self._debug_points = debug_points + self._meta = meta + + def with_meta(self, meta): + return Code(self._name, self._arity, self._bytecode, self._consts, self._stack_size, self._debug_points, meta=meta) + + def get_debug_points(self): + return self._debug_points + + def invoke(self, args): + if len(args) == self.get_arity(): + return self.invoke_with(args, self) + else: + runtime_error(u"Invalid number of arguments " + unicode(str(len(args))) + + u" for function '" + unicode(str(self._name)) + u"'. Expected " + + unicode(str(self.get_arity())), + u":pixie.stdlib/InvalidArityException") + + def invoke_with(self, args, this_fn): + try: + return interpret(self, args, self_obj=this_fn) + except object.WrappedException as ex: + ex._ex._trace.append(object.PixieCodeInfo(self._name)) + raise + + @elidable_promote() + def get_arity(self): + return self._arity + + @elidable_promote() + def get_consts(self): + return self._consts + + @elidable_promote() + def get_bytecode(self): + return self._bytecode + + @elidable_promote() + def stack_size(self): + return self._stack_size + + @elidable_promote() + def get_base_code(self): + return self + + +class VariadicCode(BaseCode): + _immutable_fields_ = ["_required_arity", "_code", "_meta"] + _type = object.Type(u"pixie.stdlib.VariadicCode") + + def type(self): + return VariadicCode._type + + def __init__(self, code, required_arity, meta=nil): + BaseCode.__init__(self) + self._required_arity = r_uint(required_arity) + self._code = code + self._meta = meta + + def with_meta(self, meta): + return VariadicCode(self._code, self._required_arity, meta) + + def name(self): + return None + + def required_arity(self): + return self._required_arity + + def invoke(self, args): + return self.invoke_with(args, self) + + def invoke_with(self, args, self_fn): + from pixie.vm2.array import array + argc = len(args) + if self._required_arity == 0: + return self._code.invoke_with([array(args)], self_fn) + if argc == self._required_arity: + new_args = resize_list(args, len(args) + 1) + new_args[len(args)] = array([]) + return self._code.invoke_with(new_args, self_fn) + elif argc > self._required_arity: + start = slice_from_start(args, self._required_arity, 1) + rest = slice_to_end(args, self._required_arity) + start[self._required_arity] = array(rest) + return self._code.invoke_with(start, self_fn) + affirm(False, u"Got " + unicode(str(argc)) + u" arg(s) need at least " + unicode(str(self._required_arity))) + + +class Closure(BaseCode): + _type = object.Type(u"pixie.stdlib.Closure") + _immutable_fields_ = ["_closed_overs[*]", "_code", "_meta"] + + def type(self): + return Closure._type + + def __init__(self, code, closed_overs, meta=nil): + BaseCode.__init__(self) + affirm(isinstance(code, Code), u"Code argument to Closure must be an instance of Code") + self._code = code + self._closed_overs = closed_overs + self._meta = meta + + def with_meta(self, meta): + return Closure(self._code, self._closed_overs, meta) + + + def name(self): + return None + + def invoke(self, args): + return self.invoke_with(args, self) + + def invoke_with(self, args, self_fn): + try: + return interpret(self, args, self_obj=self_fn) + except object.WrappedException as ex: + code = self._code + assert isinstance(code, Code) + ex._ex._trace.append(object.PixieCodeInfo(code._name)) + raise + + def get_closed_over(self, idx): + return self._closed_overs[idx] + + def get_consts(self): + return self._code.get_consts() + + def get_bytecode(self): + return self._code.get_bytecode() + + def stack_size(self): + return self._code.stack_size() + + def get_closed_overs(self): + return self._closed_overs + + def get_base_code(self): + return self._code.get_base_code() + + def get_debug_points(self): + return self._code.get_debug_points() + + +class Undefined(object.Object): + _type = object.Type(u"pixie.stdlib.Undefined") + + def type(self): + return Undefined._type + +undefined = Undefined() + + +class DynamicVars(py_object): + def __init__(self): + self._vars = rt.cons(rt.hashmap(), nil) + + def push_binding_frame(self): + self._vars = rt.cons(rt.first(self._vars), self._vars) + + def pop_binding_frame(self): + self._vars = rt.next(self._vars) + + def current_frame(self): + return rt.first(self._vars) + + def get_current_frames(self): + return self._vars + + def set_current_frames(self, vars): + self._vars = vars + + def get_var_value(self, var, not_found): + return rt._val_at(self.current_frame(), var, not_found) + + def set_var_value(self, var, val): + cur_frame = self.current_frame() + self.pop_binding_frame() + self._vars = rt.cons(rt._assoc(cur_frame, var, val), self._vars) + + + + +class Var(BaseCode): + _type = object.Type(u"pixie.stdlib.Var") + _immutable_fields_ = ["_rev?"] + + def type(self): + return Var._type + + def __init__(self, ns, name): + BaseCode.__init__(self) + self._ns = ns + self._name = name + self._rev = 0 + self._root = undefined + self._dynamic = False + + def set_root(self, o): + affirm(o is not None, u"Invalid var set") + self._rev += 1 + self._root = o + return self + + def set_value(self, val): + affirm(self._dynamic, u"Can't set the value of a non-dynamic var") + _dynamic_vars.set_var_value(self, val) + return self + + def set_dynamic(self): + self._dynamic = True + self._rev += 1 + + + def get_dynamic_value(self): + return _dynamic_vars.get_var_value(self, self._root) + + + + @elidable_promote() + def _is_dynamic(self, rev): + return self._dynamic + + def is_dynamic(self): + return self._is_dynamic(self._rev) + + @elidable_promote() + def get_root(self, rev): + return self._root + + def deref(self): + if self.is_dynamic(): + if we_are_translated(): + return self.get_dynamic_value() + else: + ## NOT RPYTHON + if globals().has_key("_dynamic_vars"): + return self.get_dynamic_value() + else: + return self.get_root(self._rev) + else: + val = self.get_root(self._rev) + affirm(val is not undefined, u"Var " + self._name + u" is undefined") + return val + + def is_defined(self): + return self._root is not undefined + + def invoke_with(self, args, this_fn): + return self.invoke(args) + + def invoke_k(self, args, stack): + return self.deref().invoke_k(args, stack) + +class bindings(py_object): + def __init__(self, *args): + self._args = list(args) + + def __enter__(self): + _dynamic_vars.push_binding_frame() + for x in range(0, len(self._args), 2): + self._args[x].set_value(self._args[x + 1]) + + def __exit__(self, exc_type, exc_val, exc_tb): + _dynamic_vars.pop_binding_frame() + + +class Refer(py_object): + def __init__(self, ns, refer_syms=[], refer_all=False): + self._namespace = ns + self._refer_syms = refer_syms + self._refer_all = refer_all + + +class Namespace(object.Object): + _type = object.Type(u"pixie.stdlib.Namespace") + + def type(self): + return Namespace._type + + def __init__(self, name): + self._registry = {} + self._name = name + self._refers = {} + + def intern_or_make(self, name): + assert name is not None + affirm(isinstance(name, unicode), u"Var names must be unicode") + v = self._registry.get(name, None) + if v is None: + v = Var(self._name, name) + self._registry[name] = v + return v + + def add_refer(self, ns, as_nm=None, refer_all=False): + assert isinstance(ns, Namespace) + if as_nm is not None: + assert isinstance(as_nm, unicode) + + if as_nm is None: + as_nm = ns._name + + self._refers[as_nm] = Refer(ns, refer_all=refer_all) + + def add_refer_symbol(self, sym, var): + assert isinstance(self, Namespace) + + name = rt.name(sym) + prev_binding = self._registry.get(name, None) + if prev_binding is not None: + print rt.name(rt.str(rt.wrap(u"Warning: "), sym, rt.wrap(u" already refers to "), prev_binding)) + + self._registry[name] = var + return var + + def include_stdlib(self): + stdlib = _ns_registry.find_or_make(u"pixie.stdlib") + self.add_refer(stdlib, refer_all=True) + + def resolve(self, s, use_refers=True): + import pixie.vm2.symbol as symbol + affirm(isinstance(s, symbol.Symbol), u"Must resolve symbols") + ns = rt.namespace(s) + name = rt.name(s) + + if ns is not None: + refer = self._refers.get(ns, None) + resolved_ns = None + if refer is not None: + resolved_ns = refer._namespace + if resolved_ns is None: + resolved_ns = _ns_registry.get(ns, None) + if resolved_ns is None: + affirm(False, u"Unable to resolve namespace: " + ns + u" inside namespace " + self._name) + else: + resolved_ns = self + + assert isinstance(resolved_ns, Namespace) + + var = resolved_ns._registry.get(name, None) + if var is None and use_refers: + for refer_nm in self._refers: + refer = self._refers[refer_nm] + if name in refer._refer_syms or refer._refer_all: + var = refer._namespace.resolve(symbol.Symbol(name), False) + if var is not None: + return var + return None + return var + + def get(self, name, default): + return self._registry.get(name, default) + + +class NamespaceRegistry(py_object): + def __init__(self): + self._registry = {} + + def find_or_make(self, name): + #affirm(isinstance(name, unicode), u"Namespace names must be unicode") + v = self._registry.get(name, None) + if v is None: + v = Namespace(name) + self._registry[name] = v + return v + + def get(self, name, default): + return self._registry.get(name, default) + +_ns_registry = NamespaceRegistry() + + +def intern_var(ns, name=None): + if name is None: + name = ns + ns = u"" + + return _ns_registry.find_or_make(ns).intern_or_make(name) + + +def get_var_if_defined(ns, name, els=None): + w_ns = _ns_registry.get(ns, None) + if w_ns is None: + return els + return w_ns.get(name, els) + + +class DefaultProtocolFn(NativeFn): + def __init__(self, pfn): + BaseCode.__init__(self) + self._pfn = pfn + + def invoke(self, args): + tp = args[0].type() + assert isinstance(tp, object.Type) + pfn = self._pfn + if isinstance(pfn, PolymorphicFn): + protocol = pfn._protocol + elif isinstance(pfn, DoublePolymorphicFn): + protocol = pfn._protocol + else: + assert False + assert isinstance(protocol, Protocol) + affirm(False, u"No override for " + tp._name + u" on " + self._pfn._name + u" in protocol " + protocol._name) + + +class Protocol(object.Object): + _type = object.Type(u"pixie.stdlib.Protocol") + + _immutable_fields_ = ["_rev?"] + + def type(self): + return Protocol._type + + def __init__(self, name): + self._name = name + self._polyfns = {} + self._satisfies = {} + self._rev = 0 + + def add_method(self, pfn): + self._polyfns[pfn] = pfn + + def add_satisfies(self, tp): + self._satisfies[tp] = tp + self._rev += 1 + + @elidable_promote() + def _get_satisfies(self, tp, rev): + return tp in self._satisfies + + def satisfies(self, tp): + return self._get_satisfies(tp, self._rev) + + +class PolymorphicFn(BaseCode): + _type = object.Type(u"pixie.stdlib.PolymorphicFn") + + def type(self): + return PolymorphicFn._type + + _immutable_fields_ = ["_rev?"] + + def __init__(self, name, protocol): + BaseCode.__init__(self) + self._name = name + self._dict = {} + # stored separately to allow ordered extending (e.g. more general protocols later) + self._protos = [] + self._rev = 0 + self._protocol = protocol + self._default_fn = DefaultProtocolFn(self) + self._fn_cache = {} + protocol.add_method(self) + + def extend(self, tp, fn): + self._dict[tp] = fn + if isinstance(tp, Protocol): + self._protos.append(tp) + self._rev += 1 + self._fn_cache = {} + self._protocol.add_satisfies(tp) + + def _find_parent_fn(self, tp): + ## Search the entire object tree to find the function to execute + assert isinstance(tp, object.Type) + + find_tp = tp + while True: + result = self._dict.get(find_tp, None) + if result is not None: + return result + + for proto in self._protos: + if proto.satisfies(find_tp): + return self._dict[proto] + + find_tp = find_tp._parent + if find_tp is None: + break + + return self._default_fn + + def set_default_fn(self, fn): + self._default_fn = fn + self._rev += 1 + self._fn_cache = {} + + @elidable_promote() + def get_protocol_fn(self, tp, rev): + fn = self._fn_cache.get(tp, None) + if fn is None: + fn = self._find_parent_fn(tp) + self._fn_cache[tp] = fn + + return promote(fn) + + def invoke(self, args): + affirm(len(args) >= 1, u"Wrong number of args") + a = args[0].type() + fn = self.get_protocol_fn(a, self._rev) + try: + return fn.invoke(args) + except object.WrappedException as ex: + ex._ex._trace.append(object.PolymorphicCodeInfo(self._name, args[0].type())) + raise + + +class DoublePolymorphicFn(BaseCode): + """A function that is polymorphic on the first two arguments""" + _type = object.Type(u"pixie.stdlib.DoublePolymorphicFn") + + def type(self): + return DefaultProtocolFn._type + + _immutable_fields_ = ["_rev?"] + + def __init__(self, name, protocol): + BaseCode.__init__(self) + self._name = name + self._dict = {} + self._rev = 0 + self._protocol = protocol + self._default_fn = DefaultProtocolFn(self) + protocol.add_method(self) + + def extend2(self, tp1, tp2, fn): + d1 = self._dict.get(tp1, None) + if d1 is None: + d1 = {} + self._dict[tp1] = d1 + d1[tp2] = fn + self._rev += 1 + self._protocol.add_satisfies(tp1) + + def set_default_fn(self, fn): + self._default_fn = fn + self._rev += 1 + + @elidable_promote() + def get_fn(self, tp1, tp2, _rev): + d1 = self._dict.get(tp1, None) + if d1 is None: + return self._default_fn + fn = d1.get(tp2, self._default_fn) + return promote(fn) + + def invoke_k(self, args, stack): + affirm(len(args) >= 2, u"DoublePolymorphicFunctions take at least two args") + a = args[0].type() + b = args[1].type() + fn = self.get_fn(a, b, self._rev) + return fn.invoke_k(args, stack) + + +# class ElidableFn(object.Object): +# _type = object.Type(u"pixie.stdlib.ElidableFn") +# __immutable_fields__ = ["_boxed_fn"] +# def type(self): +# return ElidableFn._type +# +# def __init__(self, boxed_fn): +# self._boxed_fn = boxed_fn +# +# @elidable +# def _elidable_invoke_0(self, fn): +# return self._boxed_fn.invoke([]) +# +# @elidable +# def _elidable_invoke_1(self, fn, arg0): +# return self._boxed_fn.invoke([arg0]) +# +# @elidable +# def _elidable_invoke_2(self, fn, arg0, arg1): +# return self._boxed_fn.invoke([arg0, arg1]) +# +# +# def invoke(self, args): +# largs = jit.promote(len(args)) +# fn = self._boxed_fn.promote() +# if largs == 0: +# return self._elidable_invoke_0(fn).promote() +# elif largs == 1: +# return self._elidable_invoke_1(fn, args[0].promote()).promote() +# elif largs == 2: +# return self._elidable_invoke_2(fn, args[0].promote(), args[1].promote()).promote() +# affirm(False, u"Too many args to Elidable Fn") + + +def munge(s): + return s.replace("-", "_").replace("?", "_QMARK_").replace("!", "_BANG_") + + +import inspect + + +def defprotocol(ns, name, methods): + """Define a protocol in the given namespace with the given name and methods, vars will + be created in the namespace for the protocol and methods. This function will dump + variables for the created protocols/methods in the globals() where this function is called.""" + ns = unicode(ns) + name = unicode(name) + methods = map(unicode, methods) + gbls = inspect.currentframe().f_back.f_globals + proto = Protocol(name) + intern_var(ns, name).set_root(proto) + gbls[munge(name)] = proto + for method in methods: + poly = PolymorphicFn(method, proto) + intern_var(ns, method).set_root(poly) + gbls[munge(method)] = poly + + +def assert_type(x, tp): + affirm(isinstance(x, tp), u"Fatal Error, this should never happen") + return x + + +## PYTHON FLAGS +CO_VARARGS = 0x4 + + +def wrap_fn(fn, tp=object.Object): + """Converts a native Python function into a pixie function.""" + docstring = unicode(fn.__doc__) if fn.__doc__ else u"" + def as_native_fn(f): + return type("W" + fn.__name__, (NativeFn,), {"inner_invoke": f, "_doc": docstring})() + + def as_variadic_fn(f): + return type("W" + fn.__name__[:len("__args")], (NativeFn,), {"inner_invoke": f, "_doc": docstring})() + + code = fn.func_code + if fn.__name__.endswith("__args"): + return as_variadic_fn(lambda self, args: fn(args)) + + fn_name = unicode(getattr(fn, "__real_name__", fn.__name__)) + + if code.co_flags & CO_VARARGS: + raise Exception("Variadic functions not supported by wrap") + else: + argc = code.co_argcount + if argc == 0: + def wrapped_fn(self, args): + affirm(len(args) == 0, u"Expected 0 arguments to " + fn_name) + try: + return fn() + except object.WrappedException as ex: + #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) + raise + return as_native_fn(wrapped_fn) + + if argc == 1: + def wrapped_fn(self, args): + affirm(len(args) == 1, u"Expected 1 arguments to " + fn_name) + try: + return fn(args[0]) + except object.WrappedException as ex: + #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) + raise + return as_native_fn(wrapped_fn) + + if argc == 2: + def wrapped_fn(self, args): + affirm(len(args) == 2, u"Expected 2 arguments to " + fn_name) + try: + return fn(args[0], args[1]) + except object.WrappedException as ex: + #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) + raise + return as_native_fn(wrapped_fn) + if argc == 3: + def wrapped_fn(self, args): + affirm(len(args) == 3, u"Expected 3 arguments to " + fn_name) + + try: + return fn(args[0], args[1], args[2]) + except object.WrappedException as ex: + #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) + raise + return as_native_fn(wrapped_fn) + + if argc == 4: + def wrapped_fn(self, args): + affirm(len(args) == 4, u"Expected 4 arguments to " + fn_name) + + try: + return fn(args[0], args[1], args[2], args[3]) + except object.WrappedException as ex: + ex._ex._trace.append(object.NativeCodeInfo(fn_name)) + raise + return as_native_fn(wrapped_fn) + + assert False, "implement more" + + +def extend(pfn, tp1, tp2=None): + """Extends a protocol to the given Type (not python type), with the decorated function + wraps the decorated function""" + if isinstance(tp1, type): + assert_tp = tp1 + tp1 = tp1._type + else: + assert_tp = object.Object + + def extend_inner(fn): + if tp2 is None: + pfn.extend(tp1, wrap_fn(fn, assert_tp)) + else: + pfn.extend2(tp1, tp2, wrap_fn(fn, assert_tp)) + + return pfn + + return extend_inner + + +def as_var(ns, name=None): + """Locates a var with the given name (defaulting to the namespace pixie.stdlib), sets + the root to the decorated function. If the function is not an instance of BaseCode it will + be wrapped. """ + if name is None: + name = ns + ns = "pixie.stdlib" + + name = name if isinstance(name, unicode) else unicode(name) + ns = ns if isinstance(ns, unicode) else unicode(ns) + + var = intern_var(ns, name) + + def with_fn(fn): + fn.__real_name__ = name + if not isinstance(fn, object.Object): + fn = wrap_fn(fn) + var.set_root(fn) + return fn + return with_fn + + +def returns(type): + """Tags a var as for unwrapping in rt. When rt imports this var it will be automatically converted to this type""" + def with_fn(fn): + fn._returns = type + return fn + return with_fn + + + +class bindings(py_object): + def __init__(self, *args): + self._args = list(args) + + def __enter__(self): + _dynamic_vars.push_binding_frame() + for x in range(0, len(self._args), 2): + self._args[x].set_value(self._args[x + 1]) + + def __exit__(self, exc_type, exc_val, exc_tb): + _dynamic_vars.pop_binding_frame() + + +def init(): + pass + #globals()["_dynamic_vars"] = DynamicVars() diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py new file mode 100644 index 00000000..f67bcf35 --- /dev/null +++ b/pixie/vm2/interpreter.py @@ -0,0 +1,191 @@ +from pixie.vm2.object import Object, Type, Continuation, stack_cons +from pixie.vm2.primitives import nil, false +from pixie.vm2.array import Array +import pixie.vm2.code as code +from pixie.vm2.code import BaseCode + +import rpython.rlib.jit as jit + +class AST(Object): + _immutable_fields_ = ["_c_meta"] + should_enter_jit = False + def __init__(self, meta): + self._c_meta = meta + + +class InterpretK(Continuation): + _immutable_ = True + def __init__(self, ast, locals): + self._c_ast = ast + self._c_locals = locals + + def call_continuation(self, val, stack): + ast = jit.promote(self._c_ast) + return ast.interpret(val, self._c_locals, stack) + +class Const(AST): + _immutable_fields_ = ["_c_val"] + _type = Type(u"pixie.interpreter.Const") + def __init__(self, val, meta=nil): + AST.__init__(self, meta) + self._c_val = val + + def interpret(self, _, locals, stack): + return jit.promote(self._c_val), stack + +class Locals(object): + _immutable_ = True + def __init__(self, name, value, next): + self._c_value = value + self._c_name = name + self._c_next = next + + @staticmethod + @jit.unroll_safe + def get_local(self, name): + if self is None: + return nil + c = self + while c._c_name is not name: + c = c._c_next + return c._c_value + +class Lookup(AST): + _immutable_fields_ = ["_c_name"] + def __init__(self, name, meta=nil): + AST.__init__(self, meta) + self._c_name = name + + def interpret(self, _, locals, stack): + return Locals.get_local(locals, self._c_name), stack + + +class Fn(AST): + _immutable_fields_ = ["_c_name", "_c_args", "_c_body", "_c_closed_overs"] + def __init__(self, name, args, body, meta=nil): + AST.__init__(self, meta) + self._c_name = name + self._c_args = args + self._c_body = body + + @jit.unroll_safe + def interpret(self, _, locals, stack): + return InterpretedFn(self._c_name, self._c_args, self._c_body), stack + +class InterpretedFn(code.BaseCode): + _immutable_fields_ = ["_c_arg_names", "_c_locals", "_c_fn_ast"] + def __init__(self, name, arg_names, ast): + self._c_arg_names = arg_names + if name is not nil: + self._c_locals = Locals(name, self, None) + else: + self._c_locals = None + self._c_fn_ast = ast + + @jit.unroll_safe + def invoke_k(self, args, stack): + # TODO: Check arg count + locals = jit.promote(self._c_locals) + for idx in range(len(self._c_arg_names)): + locals = Locals(self._c_arg_names[idx], args[idx], locals) + + return nil, stack_cons(stack, InterpretK(self._c_fn_ast, locals)) + + +class Invoke(AST): + _immutable_fields_ = ["_c_args", "_c_fn"] + def __init__(self, args, meta=nil): + AST.__init__(self, meta) + self._c_args = args + + def interpret(self, _, locals, stack): + stack = stack_cons(stack, InvokeK(self)) + stack = stack_cons(stack, ResolveAllK(self._c_args, locals, [])) + stack = stack_cons(stack, InterpretK(self._c_args[0], locals)) + return nil, stack + +class InvokeK(Continuation): + _immutable_ = True + def __init__(self, ast): + self._c_ast = ast + + def call_continuation(self, val, stack): + assert isinstance(val, Array) + fn = val._list[0] + args = val._list[1:] + return fn.invoke_k(args, stack) + + + +class TailCall(AST): + _immutable_fields_ = ["_c_args", "_c_fn"] + def __init__(self, args, meta=nil): + AST.__init__(self, meta) + self._c_args = args + + def interpret(self, _, locals, stack): + stack = stack_cons(stack, TailCallK(self)) + stack = stack_cons(stack, ResolveAllK(self._c_args, locals, [])) + stack = stack_cons(stack, InterpretK(self._c_args[0], locals)) + return nil, stack + +class TailCallK(InvokeK): + _immutable_ = True + should_enter_jit = True + def __init__(self, ast): + InvokeK.__init__(self, ast) + +class ResolveAllK(Continuation): + _immutable_ = True + def __init__(self, args, locals, acc): + self._c_args = args + self._c_locals = locals + self._c_acc = acc + + @jit.unroll_safe + def append_to_acc(self, val): + acc = [None] * (len(self._c_acc) + 1) + for x in range(len(self._c_acc)): + acc[x] = self._c_acc[x] + acc[len(self._c_acc)] = val + return acc + + def call_continuation(self, val, stack): + if len(self._c_acc) + 1 < len(self._c_args): + stack = stack_cons(stack, ResolveAllK(self._c_args, self._c_locals, self.append_to_acc(val))) + stack = stack_cons(stack, InterpretK(self._c_args[len(self._c_acc) + 1], self._c_locals)) + else: + return Array(self.append_to_acc(val)), stack + + return val, stack + + + + +class If(AST): + _immutable_fields_ = ["_c_test", "_c_then", "_c_else"] + def __init__(self, test, then, els, meta=nil): + AST.__init__(self, meta) + self._c_test = test + self._c_then = then + self._c_else = els + + def interpret(self, val, locals, stack): + stack = stack_cons(stack, IfK(self, locals)) + stack = stack_cons(stack, InterpretK(self._c_test, locals)) + return nil, stack + +class IfK(Continuation): + _immutable_ = True + def __init__(self, ast, locals): + self._c_ast = ast + self._c_locals = locals + + def call_continuation(self, val, stack): + ast = self._c_ast + assert isinstance(self._c_ast, If) + if val is nil or val is false: + stack = stack_cons(stack, InterpretK(ast._c_else, self._c_locals)) + else: + stack = stack_cons(stack, InterpretK(ast._c_then, self._c_locals)) + return nil, stack \ No newline at end of file diff --git a/pixie/vm2/keyword.py b/pixie/vm2/keyword.py new file mode 100644 index 00000000..74778798 --- /dev/null +++ b/pixie/vm2/keyword.py @@ -0,0 +1,81 @@ +from pixie.vm2.object import Object, Type +from pixie.vm2.primitives import nil +from pixie.vm2.string import String +#import pixie.vm.stdlib as proto +from pixie.vm.code import extend, as_var +import pixie.vm.rt as rt +#import pixie.vm.util as util +from rpython.rlib.rarithmetic import intmask + + +class Keyword(Object): + _type = Type(u"pixie.stdlib.Keyword") + def __init__(self, name): + self._str = name + self._w_name = None + self._w_ns = None + self._hash = 0 + + def type(self): + return Keyword._type + + def init_names(self): + if self._w_name is None: + s = self._str.split(u"/") + if len(s) == 2: + self._w_ns = rt.wrap(s[0]) + self._w_name = rt.wrap(s[1]) + elif len(s) == 1: + self._w_name = rt.wrap(s[0]) + self._w_ns = nil + else: + self._w_ns = rt.wrap(s[0]) + self._w_name = rt.wrap(u"/".join(s[1:])) + + +class KeywordCache(object): + def __init__(self): + self._cache = {} + + def intern(self, nm): + kw = self._cache.get(nm, None) + + if kw is None: + kw = Keyword(nm) + self._cache[nm] = kw + + return kw + +_kw_cache = KeywordCache() + +def keyword(nm, ns=None): + if ns: + nm = u"/".join([ns, nm]) + return _kw_cache.intern(nm) + +# +# @extend(proto._name, Keyword) +# def _name(self): +# assert isinstance(self, Keyword) +# self.init_names() +# return self._w_name +# +# @extend(proto._namespace, Keyword) +# def _namespace(self): +# assert isinstance(self, Keyword) +# self.init_names() +# return self._w_ns +# +# @extend(proto._hash, Keyword) +# def _hash(self): +# assert isinstance(self, Keyword) +# if self._hash == 0: +# self._hash = util.hash_unencoded_chars(self._str) +# return rt.wrap(intmask(self._hash)) +# +# @as_var("keyword") +# def _keyword(s): +# if not isinstance(s, String): +# from pixie.vm.object import runtime_error +# runtime_error(u"Symbol name must be a string") +# return keyword(s._str) diff --git a/pixie/vm2/numbers.py b/pixie/vm2/numbers.py new file mode 100644 index 00000000..85582751 --- /dev/null +++ b/pixie/vm2/numbers.py @@ -0,0 +1,431 @@ +import pixie.vm2.object as object +from pixie.vm2.object import affirm +from pixie.vm2.primitives import true, false +from rpython.rlib.rarithmetic import r_uint +from rpython.rlib.rbigint import rbigint +import rpython.rlib.jit as jit +from pixie.vm2.code import DoublePolymorphicFn, extend, Protocol, as_var, wrap_fn +#from pixie.vm.libs.pxic.util import add_marshall_handlers +import pixie.vm2.rt as rt + +import math + +class Number(object.Object): + _type = object.Type(u"pixie.stdlib.Number") + + def type(self): + return Number._type + +class Integer(Number): + _type = object.Type(u"pixie.stdlib.Integer", Number._type) + _immutable_fields_ = ["_int_val"] + + def __init__(self, i_val): + self._int_val = i_val + + def int_val(self): + return self._int_val + + def r_uint_val(self): + return r_uint(self._int_val) + + def promote(self): + return Integer(jit.promote(self._int_val)) + + def type(self): + return Integer._type + +zero_int = Integer(0) +one_int = Integer(1) + +class BigInteger(Number): + _type = object.Type(u"pixie.stdlib.BigInteger", Number._type) + _immutable_fields_ = ["_bigint_val"] + + def __init__(self, bi_val): + self._bigint_val = bi_val + + def bigint_val(self): + return self._bigint_val + + def type(self): + return BigInteger._type + +class Float(Number): + _type = object.Type(u"pixie.stdlib.Float", Number._type) + _immutable_fields_ = ["_float_val"] + + def __init__(self, f_val): + self._float_val = f_val + + def float_val(self): + return self._float_val + + def type(self): + return Float._type + +class Ratio(Number): + _type = object.Type(u"pixie.stdlib.Ratio", Number._type) + _immutable_fields_ = ["_numerator", "_denominator"] + + def __init__(self, numerator, denominator): + assert numerator is not None and denominator is not None + self._numerator = numerator + self._denominator = denominator + + def numerator(self): + return self._numerator + + def denominator(self): + return self._denominator + + def type(self): + return Ratio._type + +@wrap_fn +def ratio_write(obj): + assert isinstance(obj, Ratio) + return rt.vector(rt.wrap(obj.numerator()), rt.wrap(obj.denominator())) + +@wrap_fn +def ratio_read(obj): + return Ratio(rt.nth(obj, rt.wrap(0)).int_val(), rt.nth(obj, rt.wrap(1)).int_val()) + +#add_marshall_handlers(Ratio._type, ratio_write, ratio_read) + +IMath = as_var("IMath")(Protocol(u"IMath")) +_add = as_var("-add")(DoublePolymorphicFn(u"-add", IMath)) +_sub = as_var("-sub")(DoublePolymorphicFn(u"-sub", IMath)) +_mul = as_var("-mul")(DoublePolymorphicFn(u"-mul", IMath)) +_div = as_var("-div")(DoublePolymorphicFn(u"-div", IMath)) +_quot = as_var("-quot")(DoublePolymorphicFn(u"-quot", IMath)) +_rem = as_var("-rem")(DoublePolymorphicFn(u"-rem", IMath)) +_lt = as_var("-lt")(DoublePolymorphicFn(u"-lt", IMath)) +_gt = as_var("-gt")(DoublePolymorphicFn(u"-gt", IMath)) +_lte = as_var("-lte")(DoublePolymorphicFn(u"-lte", IMath)) +_gte = as_var("-gte")(DoublePolymorphicFn(u"-gte", IMath)) +_num_eq = as_var("-num-eq")(DoublePolymorphicFn(u"-num-eq", IMath)) +_num_eq.set_default_fn(wrap_fn(lambda a, b: false)) + +#as_var("MAX-NUMBER")(Integer(100000)) # TODO: set this to a real max number + + +num_op_template = """@extend({pfn}, {ty1}._type, {ty2}._type) +def {pfn}_{ty1}_{ty2}(a, b): + assert isinstance(a, {ty1}) and isinstance(b, {ty2}) + return {wrap_start}a.{conv1}() {op} b.{conv2}(){wrap_end} +""" + +def extend_num_op(pfn, ty1, ty2, conv1, op, conv2, wrap_start = "rt.wrap(", wrap_end = ")"): + tp = num_op_template.format(pfn=pfn, ty1=ty1.__name__, ty2=ty2.__name__, + conv1=conv1, op=op, conv2=conv2, + wrap_start=wrap_start, wrap_end=wrap_end) + exec tp + +extend_num_op("_quot", Integer, Integer, "int_val", "/", "int_val") +extend_num_op("_rem", Integer, Integer, "int_val", "%", "int_val") + +def define_num_ops(): + # maybe define get_val() instead of using tuples? + num_classes = [(Integer, "int_val"), (Float, "float_val")] + for (c1, conv1) in num_classes: + for (c2, conv2) in num_classes: + for (op, sym) in [("_add", "+"), ("_sub", "-"), ("_mul", "*"), ("_div", "/")]: + if op == "_div" and c1 == Integer and c2 == Integer: + continue + extend_num_op(op, c1, c2, conv1, sym, conv2) + if c1 != Integer or c2 != Integer: + extend_num_op("_rem", c1, c2, conv1, ",", conv2, wrap_start = "rt.wrap(math.fmod(", wrap_end = "))") + extend_num_op("_quot", c1, c2, conv1, "/", conv2, wrap_start = "rt.wrap(math.floor(", wrap_end = "))") + for (op, sym) in [("_num_eq", "=="), ("_lt", "<"), ("_gt", ">"), ("_lte", "<="), ("_gte", ">=")]: + extend_num_op(op, c1, c2, conv1, sym, conv2, + wrap_start = "true if ", wrap_end = " else false") + +define_num_ops() + +bigint_ops_tmpl = """@extend({pfn}, {ty1}._type, {ty2}._type) +def _{pfn}_{ty1}_{ty2}(a, b): + assert isinstance(a, {ty1}) and isinstance(b, {ty2}) + return rt.wrap({conv1}(a.{get1}()).{op}({conv2}(b.{get2}()))) +""" + +def define_bigint_ops(): + num_classes = [(Integer, "rbigint.fromint", "int_val"), (BigInteger, "", "bigint_val")] + for (c1, conv1, get1) in num_classes: + for (c2, conv2, get2) in num_classes: + if c1 == Integer and c2 == Integer: + continue + for (pfn, op) in [("_add", "add"), ("_sub", "sub"), ("_mul", "mul"), ("_div", "div"), + ("_num_eq", "eq"), ("_lt", "lt"), ("_gt", "gt"), ("_lte", "le"), ("_gte", "ge")]: + code = bigint_ops_tmpl.format(pfn=pfn, op=op, + ty1=c1.__name__, conv1=conv1, get1=get1, + ty2=c2.__name__, conv2=conv2, get2=get2) + exec code + +define_bigint_ops() + +def gcd(u, v): + while v != 0: + r = u % v + u = v + v = r + return u + +@extend(_div, Integer._type, Integer._type) +def _div(n, d): + assert isinstance(n, Integer) and isinstance(d, Integer) + nv = n.int_val() + dv = d.int_val() + object.affirm(dv != 0, u"Divide by zero") + g = gcd(nv, dv) + if g == 0: + return rt.wrap(0) + nv = nv / g + dv = dv / g + if dv == 1: + return rt.wrap(nv) + elif dv == -1: + return rt.wrap(-1 * nv) + else: + if dv < 0: + nv = nv * -1 + dv = dv * -1 + return Ratio(nv, dv) + +# @extend(_add, Ratio._type, Ratio._type) +# def _add(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return rt._div(rt._add(rt.wrap(b.numerator() * a.denominator()), +# rt.wrap(a.numerator() * b.denominator())), +# rt.wrap(a.denominator() * b.denominator())) +# +# @extend(_sub, Ratio._type, Ratio._type) +# def _sub(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return rt._div(rt._add(rt.wrap(-1 * b.numerator() * a.denominator()), +# rt.wrap(a.numerator() * b.denominator())), +# rt.wrap(a.denominator() * b.denominator())) +# +# @extend(_mul, Ratio._type, Ratio._type) +# def _mul(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return rt._div(rt.wrap(b.numerator() * a.numerator()), +# rt.wrap(b.denominator() * a.denominator())) +# +# @extend(_div, Ratio._type, Ratio._type) +# def _div(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return rt._div(rt.wrap(b.denominator() * a.numerator()), +# rt.wrap(b.numerator() * a.denominator())) +# +# @extend(_quot, Ratio._type, Ratio._type) +# def _quot(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return rt.wrap((a.numerator() * b.denominator()) / (a.denominator() * b.numerator())) +# +# @extend(_rem, Ratio._type, Ratio._type) +# def _rem(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# q = rt.wrap((a.numerator() * b.denominator()) / (a.denominator() * b.numerator())) +# return rt._sub(a, rt._mul(q, b)) +# +# @extend(_lt, Ratio._type, Ratio._type) +# def _lt(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return true if a.numerator() * b.denominator() < b.numerator() * a.denominator() else false +# +# @extend(_gt, Ratio._type, Ratio._type) +# def _gt(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return rt._lt(b, a) +# +# @extend(_lte, Ratio._type, Ratio._type) +# def _lte(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return true if rt._lt(b, a) is false else false +# +# @extend(_gte, Ratio._type, Ratio._type) +# def gte(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return true if rt._lt(a, b) is false else false +# +# @extend(_num_eq, Ratio._type, Ratio._type) +# def _num_eq(a, b): +# assert isinstance(a, Ratio) and isinstance(b, Ratio) +# return true if a.numerator() == b.numerator() and a.denominator() == b.denominator() else false + +mixed_op_tmpl = """@extend({pfn}, {ty1}._type, {ty2}._type) +def {pfn}_{ty1}_{ty2}(a, b): + assert isinstance(a, {ty1}) and isinstance(b, {ty2}) + return rt.{pfn}({conv1}(a), {conv2}(b)) +""" + +def to_ratio(x): + if isinstance(x, Ratio): + return x + else: + return Ratio(x.int_val(), 1) + +def to_ratio_conv(c): + if c == Ratio: + return "" + else: + return "to_ratio" + +def to_float(x): + if isinstance(x, Float): + return x + if isinstance(x, Ratio): + return rt.wrap(x.numerator() / float(x.denominator())) + if isinstance(x, BigInteger): + return rt.wrap(x.bigint_val().tofloat()) + assert False + +def to_float_conv(c): + if c == Float: + return "" + else: + return "to_float" + +def define_mixed_ops(): + for (c1, c2) in [(Integer, Ratio), (Ratio, Integer)]: + for op in ["_add", "_sub", "_mul", "_div", "_quot", "_rem", "_lt", "_gt", "_lte", "_gte", "_num_eq"]: + code = mixed_op_tmpl.format(pfn=op, ty1=c1.__name__, ty2=c2.__name__, conv1=to_ratio_conv(c1), conv2=to_ratio_conv(c2)) + exec code + + for (c1, c2) in [(Float, Ratio), (Ratio, Float)]: + for op in ["_add", "_sub", "_mul", "_div", "_quot", "_rem", "_lt", "_gt", "_lte", "_gte", "_num_eq"]: + code = mixed_op_tmpl.format(pfn=op, ty1=c1.__name__, ty2=c2.__name__, conv1=to_float_conv(c1), conv2=to_float_conv(c2)) + exec code + + for (c1, c2) in [(Float, BigInteger), (BigInteger, Float)]: + for op in ["_add", "_sub", "_mul", "_div", "_quot", "_rem", "_lt", "_gt", "_lte", "_gte", "_num_eq"]: + code = mixed_op_tmpl.format(pfn=op, ty1=c1.__name__, ty2=c2.__name__, conv1=to_float_conv(c1), conv2=to_float_conv(c2)) + exec code + +#define_mixed_ops() + +# def add(a, b): +# if isinstance(a, Integer): +# if isinstance(b, Integer): +# return Integer(a.int_val() + b.int_val()) +# +# raise Exception("Add error") + +def eq(a, b): + if isinstance(a, Integer): + if isinstance(b, Integer): + return true if a.int_val() == b.int_val() else false + + raise Exception("Add error") + + +def init(): + import pixie.vm.stdlib as proto + from pixie.vm.string import String + + @extend(proto._str, Integer._type) + def _str(i): + return rt.wrap(unicode(str(i.int_val()))) + + @extend(proto._repr, Integer._type) + def _repr(i): + return rt.wrap(unicode(str(i.int_val()))) + + @extend(proto._str, BigInteger._type) + def _str(b): + return rt.wrap(unicode(b.bigint_val().format('0123456789', suffix='N'))) + + @extend(proto._repr, BigInteger._type) + def _repr(b): + return rt.wrap(unicode(b.bigint_val().format('0123456789', suffix='N'))) + + @extend(proto._str, Float._type) + def _str(f): + return rt.wrap(unicode(str(f.float_val()))) + + @extend(proto._repr, Float._type) + def _repr(f): + return rt.wrap(unicode(str(f.float_val()))) + + @extend(proto._repr, Ratio._type) + def _repr(r): + return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator()))) + + @extend(proto._str, Ratio._type) + def _str(r): + return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator()))) + + @as_var("numerator") + def numerator(r): + affirm(isinstance(r, Ratio), u"First argument must be a Ratio") + return rt.wrap(r.numerator()) + + @as_var("denominator") + def denominator(r): + affirm(isinstance(r, Ratio), u"First argument must be a Ratio") + return rt.wrap(r.denominator()) + +from rpython.rlib.rsre import rsre_re as re +# inspired by https://github.com/clojure/tools.reader/blob/9ee11ed/src/main/clojure/clojure/tools/reader/impl/commons.clj#L45 +# sign hex oct radix decimal biginteger +# 1 2 3 4 5 6 7 8 +int_matcher = re.compile(u'^([-+]?)(?:(0[xX])([0-9a-fA-F]+)|0([0-7]+)|([1-9][0-9]?)[rR]([0-9a-zA-Z]+)|([0-9]*))(N)?$') + +float_matcher = re.compile(u'^([-+]?[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)$') +ratio_matcher = re.compile(u'^([-+]?[0-9]+)/([0-9]+)$') + +def parse_int(m): + sign = 1 + if m.group(1) == u'-': + sign = -1 + + radix = 10 + + if m.group(7): + num = m.group(7) + elif m.group(2): + radix = 16 + num = m.group(3) + elif m.group(4): + radix = 8 + num = m.group(4) + elif m.group(5): + radix = int(m.group(5)) + num = m.group(6) + else: + return None + + if m.group(8): + return rt.wrap(rbigint.fromstr(str(m.group(1) + num), radix)) + else: + return rt.wrap(sign * int(str(num), radix)) + +def parse_float(m): + return rt.wrap(float(str(m.group(0)))) + +def parse_ratio(m): + n = int(str(m.group(1))) + d = int(str(m.group(2))) + return Ratio(n, d) + +def parse_number(s): + m = int_matcher.match(s) + if m: + return parse_int(m) + else: + m = float_matcher.match(s) + if m: + return parse_float(m) + else: + m = ratio_matcher.match(s) + if m: + return parse_ratio(m) + else: + return None + +@as_var(u"-parse-number") +def _parse_number(x): + from pixie.vm2.string import String + assert isinstance(x, String) + return parse_number(x._str) \ No newline at end of file diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py new file mode 100644 index 00000000..e3e19e38 --- /dev/null +++ b/pixie/vm2/object.py @@ -0,0 +1,161 @@ +import rpython.rlib.jit as jit + +class Object(object): + """ Base Object for all VM objects + """ + _attrs_ = () + + def type(self): + affirm(False, u".type isn't overloaded") + + @jit.unroll_safe + def invoke(self, args): + #TODO: fix + runtime_error(u"bad invoke") + #import pixie.vm.stdlib as stdlib + #return stdlib.invoke_other(self, args) + + def int_val(self): + affirm(False, u"Expected Number, not " + self.type().name()) + return 0 + + def r_uint_val(self): + affirm(False, u"Expected Number, not " + self.type().name()) + return 0 + + def hash(self): + import pixie.vm.rt as rt + return rt.wrap(compute_identity_hash(self)) + + def promote(self): + return self + +class TypeRegistry(object): + def __init__(self): + self._types = {} + self._ns_registry = None + + def register_type(self, nm, tp): + if self._ns_registry is None: + self._types[nm] = tp + else: + self.var_for_type_and_name(nm, tp) + + def var_for_type_and_name(self, nm, tp): + splits = nm.split(u".") + size = len(splits) - 1 + assert size >= 0 + ns = u".".join(splits[:size]) + name = splits[size] + var = self._ns_registry.find_or_make(ns).intern_or_make(name) + var.set_root(tp) + return var + + def set_registry(self, registry): + self._ns_registry = registry + for nm in self._types: + tp = self._types[nm] + self.var_for_type_and_name(nm, tp) + + + def get_by_name(self, nm, default=None): + return self._types.get(nm, default) + +_type_registry = TypeRegistry() + +def get_type_by_name(nm): + return _type_registry.get_by_name(nm) + +class Type(Object): + def __init__(self, name, parent=None, object_inited=True): + assert isinstance(name, unicode), u"Type names must be unicode" + _type_registry.register_type(name, self) + self._name = name + + if object_inited: + if parent is None: + parent = Object._type + + parent.add_subclass(self) + + self._parent = parent + self._subclasses = [] + + def name(self): + return self._name + + def type(self): + return Type._type + + def add_subclass(self, tp): + self._subclasses.append(tp) + + def subclasses(self): + return self._subclasses + +Object._type = Type(u"pixie.stdlib.Object", None, False) +Type._type = Type(u"pixie.stdlib.Type") + +@jit.elidable_promote() +def istypeinstance(obj, t): + obj_type = obj.type() + assert isinstance(obj_type, Type) + if obj_type is t: + return True + elif obj_type._parent is not None: + obj_type = obj_type._parent + while obj_type is not None: + if obj_type is t: + return True + obj_type = obj_type._parent + return False + else: + return False + +class Continuation(object): + should_enter_jit = False + _immutable_ = True + def call_continuation(self, val, stack): + return None, stack + + +class StackCell(object): + """Defines an immutable call stack, stacks can be copied, spliced and combined""" + _immutable_fields_ = ["_parent", "_cont"] + def __init__(self, cont, parent_stack): + self._parent = parent_stack + self._cont = cont + +def stack_cons(stack, other): + return StackCell(other, stack) + + +from rpython.rlib.jit import JitDriver +jitdriver = JitDriver(greens=[], reds=["stack", "val"]) + +def run_stack(val, cont, stack=None): + stack = StackCell(cont, stack) + val = None + while stack is not None: + jitdriver.jit_merge_point(stack=stack, val=val) + cont = stack._cont + stack = stack._parent + val, stack = cont.call_continuation(val, stack) + if stack is not None and stack._cont.should_enter_jit: + jitdriver.can_enter_jit(stack=stack, val=val) + + return val + + + + +## TODO: fix +def affirm(f, msg): + if not f: + raise NotImplementedError() + +def runtime_error(msg): + raise NotImplementedError() + +class WrappedException(BaseException): + pass \ No newline at end of file diff --git a/pixie/vm2/primitives.py b/pixie/vm2/primitives.py new file mode 100644 index 00000000..b9645e4b --- /dev/null +++ b/pixie/vm2/primitives.py @@ -0,0 +1,25 @@ +import pixie.vm2.object as object + + +class Nil(object.Object): + _type = object.Type(u"pixie.stdlib.Nil") + + def __repr__(self): + return u"nil" + + def type(self): + return Nil._type + + +nil = Nil() + + +class Bool(object.Object): + _type = object.Type(u"pixie.stdlib.Bool") + + def type(self): + return Bool._type + + +true = Bool() +false = Bool() diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py new file mode 100644 index 00000000..bcbe268f --- /dev/null +++ b/pixie/vm2/rt.py @@ -0,0 +1,170 @@ +__config__ = None +py_list = list +py_str = str +from rpython.rlib.objectmodel import specialize, we_are_translated + + +def init(): + import pixie.vm.code as code + from pixie.vm2.object import affirm, _type_registry + from rpython.rlib.rarithmetic import r_uint + from rpython.rlib.rbigint import rbigint + from pixie.vm2.primitives import nil, true, false + from pixie.vm2.string import String + from pixie.vm2.object import Object + + + _type_registry.set_registry(code._ns_registry) + + def unwrap(fn): + if isinstance(fn, code.Var) and fn.is_defined() and hasattr(fn.deref(), "_returns"): + tp = fn.deref()._returns + if tp is bool: + def wrapper(*args): + ret = fn.invoke(py_list(args)) + if ret is nil or ret is false: + return False + return True + return wrapper + elif tp is r_uint: + return lambda *args: fn.invoke(py_list(args)).r_uint_val() + elif tp is unicode: + def wrapper(*args): + ret = fn.invoke(py_list(args)) + if ret is nil: + return None + + if not isinstance(ret, String): + from pixie.vm2.object import runtime_error + runtime_error(u"Invalid return value, expected String") + return ret._str + return wrapper + else: + assert False, "Don't know how to convert" + str(tp) + return lambda *args: fn.invoke(py_list(args)) + + if "__inited__" in globals(): + return + + import sys + #sys.setrecursionlimit(10000) # Yeah we blow the stack sometimes, we promise it's not a bug + + import pixie.vm2.code as code + import pixie.vm2.numbers as numbers + #import pixie.vm.bits + #import pixie.vm.interpreter + #import pixie.vm.atom + #import pixie.vm.reduced + #import pixie.vm.util + import pixie.vm2.array + #import pixie.vm.lazy_seq + #import pixie.vm.persistent_list + #import pixie.vm.persistent_hash_map + #import pixie.vm.persistent_hash_set + #import pixie.vm.custom_types + #import pixie.vm.map_entry + #import pixie.vm.libs.platform + #import pixie.vm.libs.ffi + #import pixie.vm.libs.env + #import pixie.vm.symbol + #import pixie.vm.libs.path + #import pixie.vm.libs.string + #import pixie.vm.threads + #import pixie.vm.string_builder + #import pixie.vm.stacklet + + @specialize.argtype(0) + def wrap(x): + if isinstance(x, bool): + return true if x else false + if isinstance(x, int): + return numbers.Integer(x) + if isinstance(x, rbigint): + return numbers.BigInteger(x) + if isinstance(x, float): + return numbers.Float(x) + if isinstance(x, unicode): + return String(x) + if isinstance(x, py_str): + return String(unicode(x)) + if isinstance(x, Object): + return x + if x is None: + return nil + + if not we_are_translated(): + print x, type(x) + affirm(False, u"Bad wrap") + + globals()["wrap"] = wrap + + def int_val(x): + affirm(isinstance(x, numbers.Number), u"Expected number") + return x.int_val() + + globals()["int_val"] = int_val + + from pixie.vm.code import _ns_registry, BaseCode, munge + + for name, var in _ns_registry._registry[u"pixie.stdlib"]._registry.iteritems(): + name = munge(name) + if var.is_defined() and isinstance(var.deref(), BaseCode): + globals()[name] = unwrap(var) + else: + globals()[name] = var + + import pixie.vm.bootstrap + + def reinit(): + for name, var in _ns_registry._registry[u"pixie.stdlib"]._registry.iteritems(): + name = munge(name) + if name in globals(): + continue + + if var.is_defined() and isinstance(var.deref(), BaseCode): + globals()[name] = unwrap(var) + else: + globals()[name] = var + + #f = open("pixie/stdlib.pxi") + #data = f.read() + #f.close() + #rdr = reader.MetaDataReader(reader.StringReader(unicode(data)), u"pixie/stdlib.pixie") + #result = nil + # + # @wrap_fn + # def run_load_stdlib(): + # with compiler.with_ns(u"pixie.stdlib"): + # while True: + # form = reader.read(rdr, False) + # if form is reader.eof: + # return result + # result = compiler.compile(form).invoke([]) + # reinit() + # + # stacklet.with_stacklets(run_load_stdlib) + + init_fns = [u"reduce", u"get", u"reset!", u"assoc", u"key", u"val", u"keys", u"vals", u"vec", u"load-file", u"compile-file", + u"load-ns", u"hashmap", u"cons", u"-assoc", u"-val-at"] + for x in init_fns: + globals()[py_str(code.munge(x))] = unwrap(code.intern_var(u"pixie.stdlib", x)) + + init_vars = [u"load-paths"] + for x in init_vars: + globals()[py_str(code.munge(x))] = code.intern_var(u"pixie.stdlib", x) + + #globals()[py_str(code.munge(u"ns"))] = NS_VAR + + globals()["__inited__"] = True + + globals()["is_true"] = lambda x: False if x is false or x is nil or x is None else True + + numbers.init() + code.init() + + + + + + + diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py new file mode 100644 index 00000000..6352f114 --- /dev/null +++ b/pixie/vm2/string.py @@ -0,0 +1,154 @@ +import pixie.vm2.rt as rt +from pixie.vm2.object import Object, Type, affirm +from pixie.vm2.code import extend, as_var, wrap_fn +from pixie.vm2.primitives import nil, true, false +from pixie.vm2.numbers import Integer, _add +#import pixie.vm2.stdlib as proto +#import pixie.vm2.util as util +from rpython.rlib.rarithmetic import intmask, r_uint +#from pixie.vm2.libs.pxic.util import add_marshall_handlers + +class String(Object): + _type = Type(u"pixie.stdlib.String") + + def type(self): + return String._type + + def __init__(self, s): + #assert isinstance(s, unicode) + self._str = s +# +# +# @extend(proto._str, String) +# def _str(x): +# return x +# +# @extend(proto._repr, String) +# def _repr(self): +# res = u"" +# assert isinstance(self, String) +# for c in self._str: +# if c == "\"": +# res += u"\\\"" +# elif c == "\n": +# res += u"\\n" +# elif c == "\t": +# res += u"\\t" +# elif c == "\b": +# res += u"\\b" +# elif c == "\f": +# res += u"\\f" +# elif c == "\r": +# res += u"\\r" +# else: +# res += c +# return rt.wrap(u"\"" + res + u"\"") +# +# @extend(proto._count, String) +# def _count(self): +# assert isinstance(self, String) +# return rt.wrap(len(self._str)) +# +# @extend(proto._nth, String) +# def _nth(self, idx): +# assert isinstance(self, String) +# i = idx.int_val() +# if 0 <= i < len(self._str): +# return Character(ord(self._str[i])) +# affirm(False, u"Index out of Range") +# +# @extend(proto._nth_not_found, String) +# def _nth_not_found(self, idx, not_found): +# assert isinstance(self, String) +# i = idx.int_val() +# if 0 <= i < len(self._str): +# return Character(ord(self._str[i])) +# return not_found +# +# @extend(proto._eq, String) +# def _eq(self, v): +# assert isinstance(self, String) +# if not isinstance(v, String): +# return false +# return true if self._str == v._str else false +# +# class Character(Object): +# _type = Type(u"pixie.stdlib.Character") +# _immutable_fields_ = ["_char_val"] +# +# def type(self): +# return Character._type +# +# def __init__(self, i): +# assert isinstance(i, int) +# self._char_val = i +# +# def char_val(self): +# return self._char_val +# +# @wrap_fn +# def write_char(obj): +# assert isinstance(obj, Character) +# return rt.wrap(obj._char_val) +# +# @wrap_fn +# def read_char(obj): +# return Character(obj.int_val()) +# +# add_marshall_handlers(Character._type, write_char, read_char) +# +# @extend(proto._str, Character) +# def _str(self): +# assert isinstance(self, Character) +# return rt.wrap(u"" + unichr(self.char_val())) +# +# @extend(proto._repr, Character) +# def _repr(self): +# assert isinstance(self, Character) +# cv = self.char_val() +# if cv < 128: +# return rt.wrap(u"\\"+unicode(chr(cv))) +# hexv = rt.name(rt.bit_str(rt.wrap(self.char_val()), rt.wrap(4))) +# return rt.wrap(u"\\u" + u"0" * (4 - len(hexv)) + hexv) +# +# @extend(proto._eq, Character) +# def _eq(self, obj): +# assert isinstance(self, Character) +# if self is obj: +# return true +# if not isinstance(obj, Character): +# return false +# return true if self.char_val() == obj.char_val() else false +# +# @extend(proto._hash, Character) +# def _hash(self): +# return rt.wrap(intmask(util.hash_int(r_uint(self.char_val())))) +# +# @as_var("char") +# def char(val): +# affirm(isinstance(val, Integer), u"First argument must be an Integer") +# return Character(val.int_val()) +# +# @extend(_add, Character._type, Integer._type) +# def _add(a, b): +# assert isinstance(a, Character) and isinstance(b, Integer) +# return rt._add(rt.wrap(a.char_val()), b) +# +# @extend(_add, Character._type, Character._type) +# def _add(a, b): +# assert isinstance(a, Character) and isinstance(b, Character) +# return Character(a.char_val() + b.char_val()) +# +# +# @extend(proto._name, String) +# def _name(self): +# return self +# +# @extend(proto._namespace, String) +# def _namespace(self): +# return nil +# +# @extend(proto._hash, String) +# def _hash(self): +# assert isinstance(self, String) +# return rt.wrap(intmask(util.hash_unencoded_chars(self._str))) diff --git a/target2.py b/target2.py new file mode 100644 index 00000000..8e8651db --- /dev/null +++ b/target2.py @@ -0,0 +1,125 @@ + +import pixie.vm2.interpreter as i +from pixie.vm2.object import StackCell, run_stack +import pixie.vm2.rt as rt +import pixie.vm2.code as code +from pixie.vm2.keyword import keyword as kw + +rt.init() +def testit(max): + #lt = i.Const(code.intern_var(u"pixie.stdlib", u"-lt")) + eq = i.Const(code.intern_var(u"pixie.stdlib", u"-num-eq")) + add = i.Const(code.intern_var(u"pixie.stdlib", u"-add")) + count_up = kw(u"count-up") + x = kw(u"i") + max = kw(u"max") + + f = i.Fn(count_up, [x, max], + i.If(i.Invoke([eq, i.Lookup(x), i.Lookup(max)]), + i.Lookup(x), + i.TailCall([i.Lookup(count_up), + i.Invoke([add, i.Lookup(x), i.Const(rt.wrap(1))]), + i.Lookup(max)]))) + + c = i.Invoke([f, i.Const(rt.wrap(0)), i.Const(rt.wrap(10))]) + + + return run_stack(None, i.InterpretK(c, None)) + +#val = testit() +#print val.int_val(), val + +def entry_point(): + #s = rt.wrap(u"Foo") + from pixie.vm2.string import String + s = String(u"Foo") + max = 10000 #int(args[1]) + + return testit(max).int_val() + +## JIT STUFF + + +from rpython.jit.codewriter.policy import JitPolicy +from rpython.rlib.jit import JitHookInterface, Counters +from rpython.rlib.rfile import create_stdio +from rpython.annotator.policy import AnnotatorPolicy +from rpython.rtyper.lltypesystem import lltype +from rpython.jit.metainterp import warmspot + +def run_child(glob, loc): + interp = loc['interp'] + graph = loc['graph'] + interp.malloc_check = False + + def returns_null(T, *args, **kwds): + return lltype.nullptr(T) + interp.heap.malloc_nonmovable = returns_null # XXX + + from rpython.jit.backend.llgraph.runner import LLGraphCPU + #LLtypeCPU.supports_floats = False # for now + apply_jit(interp, graph, LLGraphCPU) + + +def apply_jit(interp, graph, CPUClass): + print 'warmspot.jittify_and_run() started...' + policy = Policy() + warmspot.jittify_and_run(interp, graph, [], policy=policy, + listops=True, CPUClass=CPUClass, + backendopt=True, inline=True) + +def run_debug(argv): + from rpython.rtyper.test.test_llinterp import get_interpreter + + # first annotate and rtype + try: + interp, graph = get_interpreter(entry_point, [], backendopt=False, + #config=config, + #type_system=config.translation.type_system, + policy=Policy()) + except Exception, e: + print '%s: %s' % (e.__class__, e) + pdb.post_mortem(sys.exc_info()[2]) + raise + + # parent process loop: spawn a child, wait for the child to finish, + # print a message, and restart + #unixcheckpoint.restartable_point(auto='run') + + from rpython.jit.codewriter.codewriter import CodeWriter + CodeWriter.debug = True + run_child(globals(), locals()) + +#stacklet.global_state = stacklet.GlobalState() + +class DebugIFace(JitHookInterface): + def on_abort(self, reason, jitdriver, greenkey, greenkey_repr, logops, operations): + # print "Aborted Trace, reason: ", Counters.counter_names[reason], logops, greenkey_repr + pass + +import sys, pdb + +class Policy(JitPolicy, AnnotatorPolicy): + def __init__(self): + JitPolicy.__init__(self, DebugIFace()) + +def jitpolicy(driver): + return JitPolicy(jithookiface=DebugIFace()) + +def target(*args): + import pixie.vm.rt as rt + driver = args[0] + driver.exe_name = "pixie-vm" + rt.__config__ = args[0].config + + + print "ARG INFO: ", args + + + return entry_point, None + +import rpython.config.translationoption +print rpython.config.translationoption.get_combined_translation_config() + +if __name__ == "__main__": + run_debug(sys.argv) From fd9ca3f1038da0eacd56f26430e84065fdae3b15 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Wed, 6 May 2015 06:59:19 -0600 Subject: [PATCH 02/46] more improvements to the new compiler, can compile deftypes --- pixie/compiler.pxi | 202 ++++++++++++++++++++++++++++++++++----- pixie/vm2/interpreter.py | 30 +++++- pixie/vm2/object.py | 1 + pixie/vm2/rt.py | 1 + target2.py | 49 +++++++++- 5 files changed, 259 insertions(+), 24 deletions(-) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index a6afec3f..d6a8fd57 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -9,7 +9,8 @@ (seq? x) :seq (vector? x) :vector (symbol? x) :symbol - (number? x) :number))) + (number? x) :number + (keyword? x) :keyword))) (defmulti analyze-seq (fn [x] (let [f (first x)] @@ -51,7 +52,7 @@ [body] body) analyzed-bodies (reduce - analyze-fn-body + (partial analyze-fn-body name) {} arities)] {:op :fn @@ -62,9 +63,14 @@ :arities (vals analyzed-bodies)} )) -(defn analyze-fn-body [acc [args & body]] +(defn analyze-fn-body [fn-name acc [args & body]] ; TODO: Add support for variadic fns (let [arity (count args) + new-env (assoc-in *env* [:locals fn-name] {:op :binding + :type :fn-self + :name fn-name + :form fn-name + :env *env*}) new-env (reduce (fn [acc idx] (let [arg-name (nth args idx)] @@ -74,7 +80,7 @@ :name arg-name :form arg-name :env *env*}))) - *env* + new-env (range (count args)))] (assert (not (acc arity)) (str "Duplicate arity for " (cons args body))) (assoc acc arity {:op :fn-body @@ -130,7 +136,8 @@ (defmethod analyze-seq :default [[sym & args :as form]] (println form) - (let [resolved (resolve-in (the-ns (:ns *env*)) sym)] + (let [resolved (and (symbol? sym) + (resolve-in (the-ns (:ns *env*)) sym))] (if (and resolved (macro? @resolved)) (analyze-form (apply @resolved args)) @@ -145,6 +152,14 @@ (defmethod analyze-form :number [x] {:op :const + :type :number + :form x + :env *env*}) + +(defmethod analyze-form :keyword + [x] + {:op :const + :type :keyword :form x :env *env*}) @@ -156,9 +171,30 @@ [x] (if-let [local (get-in *env* [:locals x])] local - {:op :global - :env *env* - :form x})) + (maybe-var x))) + +(defmethod analyze-form :vector + [x] + (println "analyze " x) + {:op :vector + :children [:items] + :items (mapv analyze-form x) + :form x + :env *env*}) + +(defn maybe-var [x] + (let [resolved (resolve-in (the-ns (:ns *env*)) x)] + (if resolved + {:op :var + :env *env* + :ns (namespace resolved) + :name (name resolved) + :form x} + {:op :var + :env *env* + :ns (name (:ns *env*)) + :name (name x) + :form x}))) ;; ENV Functions @@ -190,6 +226,18 @@ (selector node)) post)) +(defn post-walk [f ast] + (walk f identity :children ast)) + +(defn clean-do [ast] + (post-walk + (fn [{:keys [op statements ret] :as do}] + (println ">-- " op (count statements)) + (if (and (= op :do) + (= (count statements) 0)) + (do (println "reducing ") ret) + ast)) + ast)) (defn remove-env [ast] (walk #(dissoc % :env) @@ -197,14 +245,6 @@ :children ast)) -(let [form '((fn this [i max] - (if (-lt i max) - (this (-add i 1) - max) - i)) - 1000)] - (println (string-builder @(to-rpython (atom (string-builder)) 0 (remove-env (analyze form)))))) - (defn write! [sb val] (swap! sb conj! val) sb) @@ -214,6 +254,7 @@ (write! sb " "))) (defmulti to-rpython (fn [sb offset node] + (println (:op node)) (:op node))) (defmethod to-rpython :if @@ -223,7 +264,7 @@ (let [offset (inc offset)] (doseq [[nm form] [[:test test] [:then then] - [:else else]]] + [:els else]]] (offset-spaces sb offset) (write! sb (name nm)) (write! sb "=") @@ -232,12 +273,129 @@ (offset-spaces sb offset) (write! sb ")"))) -(defmethod to-rpython :const +(defmulti write-const (fn [sb offset const] + (:type const))) + +(defmethod write-const :keyword [sb offset {:keys [form]}] - (write! sb "i.Const(rt.wrap(") - (write! sb (str form)) - (write! sb "))")) + (write! sb "kw(u\"") + (when (namespace form) + (write! sb (namespace form)) + (write! sb "/")) + (write! sb (name form)) + (write! sb "\")")) + +(defmethod to-rpython :const + [sb offset ast] + (write! sb "i.Const(") + (write-const sb offset ast) + (write! sb ")")) + +(defmethod to-rpython :invoke + [sb offset ast] + (write! sb "i.Invoke(\n") + (let [offset (inc offset)] + (offset-spaces sb offset) + (write! sb "args=[\n") + (let [offset (inc offset)] + (doseq [x `(~(:fn ast) ~@(:args ast))] + (offset-spaces sb offset) + (to-rpython sb offset x) + (write! sb ",\n"))) + (offset-spaces sb offset) + (write! sb "],\n")) + (offset-spaces sb offset) + (write! sb ")")) + + +(defmethod to-rpython :do + [sb offset {:keys [ret statements]}] + (write! sb "i.Do(\n") + (let [offset (inc offset)] + (offset-spaces sb offset) + (write! sb "args=[\n") + (let [offset (inc offset)] + (doseq [x `(~@statements ~ret)] + (offset-spaces sb offset) + (to-rpython sb offset x) + (write! sb ",\n"))) + (offset-spaces sb offset) + (write! sb "],\n")) + (offset-spaces sb offset) + (write! sb ")")) + + +(defmethod to-rpython :fn + [sb offset {:keys [name arities]}] + (assert (= (count arities) 1)) + (to-rpython-fn-body sb offset name (nth arities 0))) + +(defn to-rpython-fn-body + [sb offset name {:keys [args body]}] + (write! sb "i.Fn(args=[") + (write! sb (->> args + (map (fn [name] + (str "kw(u\"" name "\")"))) + (interpose ",") + (apply str))) + (write! sb "],name=kw(u\"") + (write! sb (str name)) + (write! sb "\"),\n") + (let [offset (inc offset)] + (offset-spaces sb offset) + (write! sb "body=") + (to-rpython sb offset body) + (write! sb ",\n")) + (offset-spaces sb offset) + (write! sb ")")) + +(defmethod to-rpython :var + [sb offset {:keys [ns name]}] + (write! sb "i.Const(code.intern_var(") + (write! sb "u\"") + (write! sb ns) + (write! sb "\", u\"") + (write! sb name) + (write! sb "\"))")) + +(defmethod to-rpython :binding + [sb offset {:keys [name]}] + (write! sb "i.Lookup(kw(u\"") + (write! sb name) + (write! sb "\"))")) + +(defmethod to-rpython :def + [sb offset {:keys [name env val]}] + (write! sb "i.Invoke(args=[\n") + (write! sb (str "# (def " (:ns env) "/" name ")\n")) + (let [offset (inc offset)] + (offset-spaces sb offset) + (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"set-var-root!\")),\n") + (offset-spaces sb offset) + (write! sb "i.Const(code.intern_var(u\"") + (write! sb (:ns env)) + (write! sb "\",u\"") + (write! sb name) + (write! sb "\")),\n") + (offset-spaces sb offset) + (to-rpython sb offset val) + (write! sb "])") + )) + +(defmethod to-rpython :vector + [sb offset {:keys [items]}] + (write! sb "i.Invoke(args=[\n") + (let [offset (inc offset)] + (offset-spaces sb offset) + (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"vector\")),\n") + (doseq [item items] + (offset-spaces sb offset) + (to-rpython sb offset item) + (write! sb ",\n")) + (offset-spaces sb offset) + (write! sb "])"))) +(let [form '(do (deftype Cons [head tail meta]))] + (println (string-builder @(to-rpython (atom (string-builder)) 0 (clean-do (analyze form)))))) -(defmethod rpython-node) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index f67bcf35..83bf243c 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -188,4 +188,32 @@ def call_continuation(self, val, stack): stack = stack_cons(stack, InterpretK(ast._c_else, self._c_locals)) else: stack = stack_cons(stack, InterpretK(ast._c_then, self._c_locals)) - return nil, stack \ No newline at end of file + return nil, stack + + +class Do(AST): + _immutable_fields_ = ["_c_body_asts"] + def __init__(self, args, meta=nil): + AST.__init__(self, meta) + self._c_body_asts = args + + @jit.unroll_safe + def interpret(self, val, locals, stack): + return val, stack_cons(stack, DoK(self._c_body_asts, locals)) + + +class DoK(Continuation): + _immutable_ = True + def __init__(self, do_asts, locals, idx=0): + self._c_locals = locals + self._c_body_asts = do_asts + self._c_idx = idx + + def call_continuation(self, val, stack): + if self._c_idx + 1 < len(self._c_body_asts): + stack = stack_cons(stack, DoK(self._c_body_asts, self._c_locals, self._c_idx + 1)) + stack = stack_cons(stack, InterpretK(self._c_body_asts[self._c_idx], self._c_locals)) + return nil, stack + else: + stack = stack_cons(stack, InterpretK(self._c_body_asts[self._c_idx], self._c_locals)) + return nil, stack diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index e3e19e38..2715c14f 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -152,6 +152,7 @@ def run_stack(val, cont, stack=None): ## TODO: fix def affirm(f, msg): if not f: + print msg raise NotImplementedError() def runtime_error(msg): diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index bcbe268f..35cc2103 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -51,6 +51,7 @@ def wrapper(*args): import pixie.vm2.code as code import pixie.vm2.numbers as numbers + import pixie.vm2.stdlib #import pixie.vm.bits #import pixie.vm.interpreter #import pixie.vm.atom diff --git a/target2.py b/target2.py index 8e8651db..7fd9b71d 100644 --- a/target2.py +++ b/target2.py @@ -23,6 +23,52 @@ def testit(max): c = i.Invoke([f, i.Const(rt.wrap(0)), i.Const(rt.wrap(10))]) + c = i.Do( + args=[ + i.Invoke(args=[ +# (def user/it) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"user", u"it")), + i.Fn(args=[kw(u"i"),kw(u"max")],name=kw(u"this"), + body=i.Do( + args=[ + i.If( + test=i.Invoke( + args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"-lt")), + + i.Lookup(kw(u"i")), + i.Lookup(kw(u"max")), + ], + ), + then=i.Invoke( + args=[ + i.Lookup(kw(u"this")), + i.Invoke( + args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"-add")), + i.Lookup(kw(u"i")), + i.Const(rt.wrap(1)), + ], + ), + i.Lookup(kw(u"max")), + ], + ), + els=i.Lookup(kw(u"i")), + ), + ], + ), + )]), + i.Invoke( + args=[ + i.Const(code.intern_var(u"user", u"it")), + i.Const(rt.wrap(0)), + i.Const(rt.wrap(1000)), + ], + ), + ], +) + return run_stack(None, i.InterpretK(c, None)) @@ -122,4 +168,5 @@ def target(*args): print rpython.config.translationoption.get_combined_translation_config() if __name__ == "__main__": - run_debug(sys.argv) + #run_debug(sys.argv) + entry_point() From ae237dd22848c2bf9b2a1db4a388c880b6bcbb2c Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Wed, 6 May 2015 23:28:16 -0600 Subject: [PATCH 03/46] latest work, can compile defprotocols and run them --- Makefile | 4 ++ pixie/compiler.pxi | 124 +++++++++++++++++++++++++++++++++++---- pixie/stdlib.pxi | 15 +++-- pixie/vm/stdlib.py | 16 +++++ pixie/vm2/array.py | 5 ++ pixie/vm2/interpreter.py | 9 +++ pixie/vm2/rt.py | 2 +- target2.py | 71 +++------------------- 8 files changed, 169 insertions(+), 77 deletions(-) diff --git a/Makefile b/Makefile index 74bdf302..226b04fd 100644 --- a/Makefile +++ b/Makefile @@ -93,3 +93,7 @@ clean: clean_pxic rm -rf ./externals rm -f ./pixie-vm rm -f ./*.pyc + +compile_rpython: + rm /tmp/pxi.py + ./pixie-vm pixie/compiler.pxi diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index d6a8fd57..3927e5a8 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -1,4 +1,16 @@ -(ns pixie.compiler) +(ns pixie.compiler + (:require [pixie.io :as io])) + +(def macro-overrides + { + (resolve 'defprotocol) + (fn + [nm & sigs] + `(do (def ~nm (protocol ~(str nm))) + ~@(map (fn [[x]] + `(def ~x (polymorphic-fn ~(str x) ~nm))) + sigs)))}) + (def *env* nil) (set-dynamic! (var *env*)) @@ -10,6 +22,7 @@ (vector? x) :vector (symbol? x) :symbol (number? x) :number + (string? x) :string (keyword? x) :keyword))) (defmulti analyze-seq (fn [x] @@ -120,6 +133,8 @@ (defmethod analyze-seq 'def [[_ nm val :as form]] + (swap! (:vars *env*) update-in [(:ns *env*) nm] (fn [x] + (or x :def))) {:op :def :name nm :form form @@ -127,9 +142,27 @@ :children [:val] :val (analyze-form val)}) +(defmethod analyze-seq 'quote + [[_ val]] + {:op :const + :type (cond + (symbol? val) :symbol + (string? val) :string + :else :unknown) + :form val}) + +(defmethod analyze-seq 'local-macro + [[_ [nm replace] body :as form]] + (binding [*env* (assoc-in *env* [:locals nm] {:op :local-macro + :name nm + :replace-with replace + :form form})] + (analyze-form body))) + (defmethod analyze-form nil [_] {:op :const + :type (keyword "nil") :env *env* :form nil}) @@ -138,9 +171,17 @@ (println form) (let [resolved (and (symbol? sym) (resolve-in (the-ns (:ns *env*)) sym))] - (if (and resolved - (macro? @resolved)) + (println "fff" (contains? macro-overrides resolved)) + (cond + (and resolved + (contains? macro-overrides resolved)) + (analyze-form (apply (macro-overrides resolved) args)) + + (and resolved + (macro? @resolved)) (analyze-form (apply @resolved args)) + + :else {:op :invoke :children '[:fn :args] :form form @@ -163,6 +204,13 @@ :form x :env *env*}) +(defmethod analyze-form :string + [x] + {:op :const + :type :string + :form x + :env *env*}) + (defmethod analyze-form :seq [x] (analyze-seq x)) @@ -170,7 +218,9 @@ (defmethod analyze-form :symbol [x] (if-let [local (get-in *env* [:locals x])] - local + (if (= (:op local) :local-macro) + (analyze-form (:replace-with local)) + local) (maybe-var x))) (defmethod analyze-form :vector @@ -184,12 +234,22 @@ (defn maybe-var [x] (let [resolved (resolve-in (the-ns (:ns *env*)) x)] - (if resolved + (cond + (get-in @(:vars *env*) [(:ns *env*) x]) + {:op :var + :env *env* + :ns (:ns *env*) + :name x + :form x} + + resolved {:op :var :env *env* :ns (namespace resolved) :name (name resolved) :form x} + + :else {:op :var :env *env* :ns (name (:ns *env*)) @@ -202,7 +262,8 @@ (defn new-env "Creates a new (empty) environment" [] - {:ns 'user}) + {:ns 'pixie.stdlib + :vars (atom nil)}) (defn analyze [form] @@ -274,6 +335,7 @@ (write! sb ")"))) (defmulti write-const (fn [sb offset const] + (println "const " const) (:type const))) (defmethod write-const :keyword @@ -285,6 +347,31 @@ (write! sb (name form)) (write! sb "\")")) +(defmethod write-const (keyword "nil") + [sb offset _] + (write! sb "nil")) + +(defmethod write-const :symbol + [sb offset {:keys [form]}] + (write! sb "sym(u\"") + (when (namespace form) + (write! sb (namespace form)) + (write! sb "/")) + (write! sb (name form)) + (write! sb "\")")) + +(defmethod write-const :string + [sb offset {:keys [form]}] + (write! sb "rt.wrap(u\"") + (write! sb form) + (write! sb "\")")) + +(defmethod write-const :number + [sb offset {:keys [form]}] + (write! sb "rt.wrap(u\"") + (write! sb (str form)) + (write! sb "\")")) + (defmethod to-rpython :const [sb offset ast] (write! sb "i.Const(") @@ -351,7 +438,7 @@ (defmethod to-rpython :var [sb offset {:keys [ns name]}] - (write! sb "i.Const(code.intern_var(") + (write! sb "i.VDeref(code.intern_var(") (write! sb "u\"") (write! sb ns) (write! sb "\", u\"") @@ -387,7 +474,7 @@ (write! sb "i.Invoke(args=[\n") (let [offset (inc offset)] (offset-spaces sb offset) - (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"vector\")),\n") + (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"array\")),\n") (doseq [item items] (offset-spaces sb offset) (to-rpython sb offset item) @@ -396,6 +483,23 @@ (write! sb "])"))) -(let [form '(do (deftype Cons [head tail meta]))] - (println (string-builder @(to-rpython (atom (string-builder)) 0 (clean-do (analyze form)))))) +(let [form '(do + (defprotocol ISeq + (-first [this]) + (-next [this])) + (defprotocol IMeta + (-meta [this])) + (deftype Cons [head tail meta] + ISeq + (-first [this] + head) + (-next [this] + tail) + IMeta + (-meta [this] + meta)) + ) + str (string-builder @(to-rpython (atom (string-builder)) 0 (clean-do (analyze form))))] + (print str) + (io/spit "/tmp/pxi.py" str)) diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index bd8011ac..92395f63 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -2042,15 +2042,22 @@ The params can be destructuring bindings, see `(doc let)` for details."} `(fn* ~@name ~(first (first decls)) ~@(next (first decls))) `(fn* ~@name ~@decls)))) -(deftype MultiMethod [dispatch-fn default-val methods] +(deftype MultiMethod [name dispatch-fn default-val methods] IFn (-invoke [self & args] (let [dispatch-val (apply dispatch-fn args) method (if (contains? @methods dispatch-val) (get @methods dispatch-val) (get @methods default-val)) - _ (assert method (str "no method defined for " dispatch-val))] - (apply method args)))) + _ (assert method (str "no method defined for " dispatch-val " on " name))] + (try + (apply method args) + (catch ex + (throw (add-exception-info ex (str "In multimethod " + name + " dispatching on " + dispatch-val + "\n") args))))))) (defmacro defmulti {:doc "Define a multimethod, which dispatches to its methods based on dispatch-fn." @@ -2069,7 +2076,7 @@ The params can be destructuring bindings, see `(doc let)` for details."} [meta args]) dispatch-fn (first args) options (apply hashmap (next args))] - `(def ~name (->MultiMethod ~dispatch-fn ~(get options :default :default) (atom {}))))) + `(def ~name (->MultiMethod ~(str name) ~dispatch-fn ~(get options :default :default) (atom {}))))) (defmacro defmethod {:doc "Define a method of a multimethod. See `(doc defmulti)` for details." diff --git a/pixie/vm/stdlib.py b/pixie/vm/stdlib.py index 05c309c3..87d1f7ca 100644 --- a/pixie/vm/stdlib.py +++ b/pixie/vm/stdlib.py @@ -893,3 +893,19 @@ def _add_exception_info(ex, str, data): assert isinstance(ex, RuntimeException) ex._trace.append(ExtraCodeInfo(rt.name(str), data)) return ex + + +@as_var("protocol-fn") +def polymorphic_fn(name, protocol): + from pixie.vm2.string import String + affirm(isinstance(name, String), u"polymorphic functions must have string names") + affirm(isinstance(protocol, code.Protocol), u"must be a protocol") + + return code.PolymorphicFn(name._str, protocol) + + +@as_var("protocol") +def protocol(name): + from pixie.vm2.string import String + affirm(isinstance(name, String), u"Protocol names must be strings") + return code.Protocol(name._str) \ No newline at end of file diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py index 50ac931c..ccf3bd96 100644 --- a/pixie/vm2/array.py +++ b/pixie/vm2/array.py @@ -35,6 +35,11 @@ def reduce_large(self, f, init): return rt.deref(init) init = f.invoke([init, self._list[x]]) return init + +@as_var("array") +def array__args(lst): + return Array(lst) + # # # @extend(proto._count, Array) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 83bf243c..77ec2beb 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -217,3 +217,12 @@ def call_continuation(self, val, stack): else: stack = stack_cons(stack, InterpretK(self._c_body_asts[self._c_idx], self._c_locals)) return nil, stack + +class VDeref(AST): + _immutable_fields_ = ["_c_var"] + def __init__(self, var, meta=nil): + AST.__init__(self, meta) + self._c_var = var + + def interpret(self, val, locals, stack): + return self._c_var.deref(), stack \ No newline at end of file diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index 35cc2103..90f8b5f0 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -62,7 +62,7 @@ def wrapper(*args): #import pixie.vm.persistent_list #import pixie.vm.persistent_hash_map #import pixie.vm.persistent_hash_set - #import pixie.vm.custom_types + import pixie.vm2.custom_types #import pixie.vm.map_entry #import pixie.vm.libs.platform #import pixie.vm.libs.ffi diff --git a/target2.py b/target2.py index 7fd9b71d..e0da79c5 100644 --- a/target2.py +++ b/target2.py @@ -4,70 +4,14 @@ import pixie.vm2.rt as rt import pixie.vm2.code as code from pixie.vm2.keyword import keyword as kw +from pixie.vm2.symbol import symbol as sym + rt.init() def testit(max): - #lt = i.Const(code.intern_var(u"pixie.stdlib", u"-lt")) - eq = i.Const(code.intern_var(u"pixie.stdlib", u"-num-eq")) - add = i.Const(code.intern_var(u"pixie.stdlib", u"-add")) - count_up = kw(u"count-up") - x = kw(u"i") - max = kw(u"max") - - f = i.Fn(count_up, [x, max], - i.If(i.Invoke([eq, i.Lookup(x), i.Lookup(max)]), - i.Lookup(x), - i.TailCall([i.Lookup(count_up), - i.Invoke([add, i.Lookup(x), i.Const(rt.wrap(1))]), - i.Lookup(max)]))) - - c = i.Invoke([f, i.Const(rt.wrap(0)), i.Const(rt.wrap(10))]) - - c = i.Do( - args=[ - i.Invoke(args=[ -# (def user/it) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"user", u"it")), - i.Fn(args=[kw(u"i"),kw(u"max")],name=kw(u"this"), - body=i.Do( - args=[ - i.If( - test=i.Invoke( - args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"-lt")), - - i.Lookup(kw(u"i")), - i.Lookup(kw(u"max")), - ], - ), - then=i.Invoke( - args=[ - i.Lookup(kw(u"this")), - i.Invoke( - args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"-add")), - i.Lookup(kw(u"i")), - i.Const(rt.wrap(1)), - ], - ), - i.Lookup(kw(u"max")), - ], - ), - els=i.Lookup(kw(u"i")), - ), - ], - ), - )]), - i.Invoke( - args=[ - i.Const(code.intern_var(u"user", u"it")), - i.Const(rt.wrap(0)), - i.Const(rt.wrap(1000)), - ], - ), - ], -) + + with open("/tmp/pxi.py") as f: + c = eval(f.read()) return run_stack(None, i.InterpretK(c, None)) @@ -78,10 +22,13 @@ def testit(max): def entry_point(): #s = rt.wrap(u"Foo") from pixie.vm2.string import String + s = String(u"Foo") max = 10000 #int(args[1]) - return testit(max).int_val() + val = testit(max) + print val + return val ## JIT STUFF From 673afabcb01a72015df5a8a248114ba9e8bd6596 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Fri, 8 May 2015 23:31:36 -0600 Subject: [PATCH 04/46] optimized the AST jit a bunch, started in on metadata support for ASTs --- Makefile | 1 + pixie/compiler.pxi | 136 +++++++++++++++++++++++++++++++-------- pixie/vm/reader.py | 6 +- pixie/vm/stdlib.py | 14 ---- pixie/vm2/code.py | 28 ++++---- pixie/vm2/interpreter.py | 39 +++++++++-- pixie/vm2/object.py | 27 +++++--- pixie/vm2/string.py | 2 +- target.py | 2 +- target2.py | 20 ++++-- 10 files changed, 198 insertions(+), 77 deletions(-) diff --git a/Makefile b/Makefile index 226b04fd..0add034a 100644 --- a/Makefile +++ b/Makefile @@ -95,5 +95,6 @@ clean: clean_pxic rm -f ./*.pyc compile_rpython: + touch /tmp/pxi.py rm /tmp/pxi.py ./pixie-vm pixie/compiler.pxi diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 3927e5a8..8c5bd119 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -16,6 +16,7 @@ (set-dynamic! (var *env*)) (defmulti analyze-form (fn [x] + (println "Meta --> " (meta x)) (cond (nil? x) nil (seq? x) :seq @@ -40,7 +41,8 @@ :children '[:statements :ret] :env *env* :form x - :statements (mapv analyze-form (butlast (next x))) + :statements (binding [*env* (assoc *env* :tail? false)] + (mapv analyze-form (butlast (next x)))) :ret (analyze-form (last x))}) (defmethod analyze-seq 'if @@ -49,7 +51,8 @@ :children '[:test :then :else] :env *env* :form form - :test (analyze-form test) + :test (binding [*env* (assoc *env* :tail? false)] + (analyze-form test)) :then (analyze-form then) :else (analyze-form else)}) @@ -78,7 +81,9 @@ (defn analyze-fn-body [fn-name acc [args & body]] ; TODO: Add support for variadic fns - (let [arity (count args) + (let [[args variadic?] (let [not& (vec (filter (complement (partial = '&)) args))] + [not& (= '& (last (butlast args)))]) + arity (count args) new-env (assoc-in *env* [:locals fn-name] {:op :binding :type :fn-self :name fn-name @@ -100,8 +105,9 @@ :env *env* :arity arity :args args + :variadic? variadic? :children '[:body] - :body (binding [*env* new-env] + :body (binding [*env* (assoc new-env :tail? true)] (analyze-form (cons 'do body)))}))) @@ -118,7 +124,8 @@ :form binding-form :env *env* :name name - :value (analyze-form binding-form)})] + :value (binding [*env* (assoc *env* :tail? false)] + (analyze-form binding-form))})] [(assoc-in new-env [:locals name] binding-ast) (conj bindings binding-ast)])) [*env* []] @@ -183,11 +190,14 @@ :else {:op :invoke + :tail-call (:tail? *env*) :children '[:fn :args] :form form :env *env* - :fn (analyze-form sym) - :args (mapv analyze-form args)}))) + :fn (binding [*env* (assoc *env* :tail? false)] + (analyze-form sym)) + :args (binding [*env* (assoc *env* :tail? false)] + (mapv analyze-form args))}))) (defmethod analyze-form :number @@ -263,7 +273,8 @@ "Creates a new (empty) environment" [] {:ns 'pixie.stdlib - :vars (atom nil)}) + :vars (atom nil) + :tail? true}) (defn analyze [form] @@ -306,9 +317,29 @@ :children ast)) -(defn write! [sb val] - (swap! sb conj! val) - sb) +(defn write! [{:keys [code] :as state} val] + (swap! code conj! val) + state) + +(defn add-meta [{:keys [meta-state meta-lines] :as state} ast] + (let [m (meta (:form ast))] + (if m + (let [k [(:line m) (:file m)] + id (get @meta-state k)] + (if id + id + (let [id (str "mid" (count @meta-state))] + (swap! meta-state assoc k id) + (swap! meta-lines conj! (str id " = (u\"" (:line m) "\", \"" (:file m) "\")\n")) + id))) + "nil"))) + +(defn meta-str [state ast] + (println (:form ast) (meta (:form ast))) + (let [m (meta (:form ast))] + (if m + (str "Meta(" (add-meta state ast) ", " (:line-number m) ", " (:column-number m) ")") + "nil"))) (defn offset-spaces [sb off] (dotimes [x off] @@ -319,7 +350,7 @@ (:op node))) (defmethod to-rpython :if - [sb offset {:keys [test then else]}] + [sb offset {:keys [test then else] :as ast}] #_(offset-spaces sb offset) (write! sb "i.If(\n") (let [offset (inc offset)] @@ -332,6 +363,9 @@ (to-rpython sb offset form) (write! sb ",\n")) (offset-spaces sb offset) + (write! sb "meta=") + (write! sb (meta-str sb ast)) + (write! sb ")"))) (defmulti write-const (fn [sb offset const] @@ -368,9 +402,9 @@ (defmethod write-const :number [sb offset {:keys [form]}] - (write! sb "rt.wrap(u\"") + (write! sb "rt.wrap(") (write! sb (str form)) - (write! sb "\")")) + (write! sb ")")) (defmethod to-rpython :const [sb offset ast] @@ -380,7 +414,9 @@ (defmethod to-rpython :invoke [sb offset ast] - (write! sb "i.Invoke(\n") + (if (:tail-call ast) + (write! sb "i.TailCall(\n") + (write! sb "i.Invoke(\n")) (let [offset (inc offset)] (offset-spaces sb offset) (write! sb "args=[\n") @@ -396,7 +432,7 @@ (defmethod to-rpython :do - [sb offset {:keys [ret statements]}] + [sb offset {:keys [ret statements] :as ast}] (write! sb "i.Do(\n") (let [offset (inc offset)] (offset-spaces sb offset) @@ -409,16 +445,39 @@ (offset-spaces sb offset) (write! sb "],\n")) (offset-spaces sb offset) + (write! sb "meta=") + (write! sb (meta-str sb ast)) (write! sb ")")) (defmethod to-rpython :fn [sb offset {:keys [name arities]}] - (assert (= (count arities) 1)) - (to-rpython-fn-body sb offset name (nth arities 0))) + (if (= (count arities) 1) + (to-rpython-fn-body sb offset name (nth arities 0)) + (do (write! sb (str "i.Invoke([i.Const(code.intern_var(u\"pixie.stdlib\", u\"multi-arity-fn\")), i.Const(rt.wrap(u\"" name "\")),\n")) + (offset-spaces sb offset) + (let [offset (inc offset)] + (doseq [f arities] + (when (not (:variadic? f)) + (offset-spaces sb offset) + (write! sb (str "i.Const(rt.wrap(" (count (:args f)) ")), ")) + (to-rpython-fn-body sb offset name f) + (write! sb ",\n"))) + (offset-spaces sb offset) + (let [vfn (first (filter :variadic? arities))] + (offset-spaces sb offset) + (write! sb (str "i.Const(rt.wrap(-1)), \n")) + (offset-spaces sb offset) + (to-rpython-fn-body sb offset name vfn) + (write! sb "\n"))) + (offset-spaces sb offset) + (write! sb "])")))) (defn to-rpython-fn-body - [sb offset name {:keys [args body]}] + [sb offset name {:keys [args body variadic?]}] + (when variadic? + (write! sb (str "i.Invoke([i.Const(code.intern_var(u\"pixie.stdlib\", u\"variadic-fn\")), i.Const(rt.wrap(" (dec (count args)) ")), \n")) + (offset-spaces sb offset)) (write! sb "i.Fn(args=[") (write! sb (->> args (map (fn [name] @@ -434,7 +493,9 @@ (to-rpython sb offset body) (write! sb ",\n")) (offset-spaces sb offset) - (write! sb ")")) + (write! sb ")") + (if variadic? + (write! sb "])"))) (defmethod to-rpython :var [sb offset {:keys [ns name]}] @@ -474,7 +535,7 @@ (write! sb "i.Invoke(args=[\n") (let [offset (inc offset)] (offset-spaces sb offset) - (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"array\")),\n") + (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"array\")),") (doseq [item items] (offset-spaces sb offset) (to-rpython sb offset item) @@ -483,7 +544,34 @@ (write! sb "])"))) -(let [form '(do +(defn writer-context [] + {:meta-lines (atom (string-builder)) + :meta-state (atom {}) + :code (atom (string-builder))}) + +(defn finish-context [{:keys [meta-lines code]}] + (str (string-builder @meta-lines) + "\n \n" + (string-builder @code))) + +(let [form + '(do (defn + + ([] 0) + ([x] x) + ([x y] (-add x y)) + ([x y & more] + (-apply + (+ x y) more))) + + ((fn c [i max] + (if (-lt i max) + (c (+ i 1 1) max) + max)) + 0 10000)) + str (finish-context (to-rpython (writer-context) 0 (clean-do (analyze form))))] + (print str) + (io/spit "/tmp/pxi.py" str)) + +#_'(do (defprotocol ISeq (-first [this]) (-next [this])) @@ -499,7 +587,3 @@ (-meta [this] meta)) ) - str (string-builder @(to-rpython (atom (string-builder)) 0 (clean-do (analyze form))))] - (print str) - (io/spit "/tmp/pxi.py" str)) - diff --git a/pixie/vm/reader.py b/pixie/vm/reader.py index d3872d12..9f469f18 100644 --- a/pixie/vm/reader.py +++ b/pixie/vm/reader.py @@ -2,7 +2,7 @@ import pixie.vm.object as object from pixie.vm.object import affirm, runtime_error import pixie.vm.code as code -from pixie.vm.code import as_var +from pixie.vm.code import as_var, extend from pixie.vm.primitives import nil, true, false import pixie.vm.numbers as numbers from pixie.vm.cons import cons @@ -17,6 +17,7 @@ from pixie.vm.persistent_hash_set import EMPTY as EMPTY_SET from pixie.vm.persistent_list import EmptyList import pixie.vm.compiler as compiler +import pixie.vm.stdlib as proto from rpython.rlib.rbigint import rbigint from rpython.rlib.rsre import rsre_re as re @@ -154,6 +155,9 @@ def __repr__(self): return self._str return u"".join(self._chrs) +@extend(proto._str, LinePromise) +def _str(x): + return rt.wrap(x.__repr__()) class MetaDataReader(PlatformReader): diff --git a/pixie/vm/stdlib.py b/pixie/vm/stdlib.py index 87d1f7ca..bcb43428 100644 --- a/pixie/vm/stdlib.py +++ b/pixie/vm/stdlib.py @@ -895,17 +895,3 @@ def _add_exception_info(ex, str, data): return ex -@as_var("protocol-fn") -def polymorphic_fn(name, protocol): - from pixie.vm2.string import String - affirm(isinstance(name, String), u"polymorphic functions must have string names") - affirm(isinstance(protocol, code.Protocol), u"must be a protocol") - - return code.PolymorphicFn(name._str, protocol) - - -@as_var("protocol") -def protocol(name): - from pixie.vm2.string import String - affirm(isinstance(name, String), u"Protocol names must be strings") - return code.Protocol(name._str) \ No newline at end of file diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index 0d9801d3..35038c1b 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -93,6 +93,7 @@ def slice_from_start(from_list, count, extra=r_uint(0)): class BaseCode(object.Object): _immutable_fields_ = ["_meta"] def __init__(self): + from pixie.vm2.string import String assert isinstance(self, BaseCode) self._name = u"unknown" self._is_macro = False @@ -185,11 +186,11 @@ def get_fn(self, arity): def get_arities(self): return self._arities.keys() - def invoke(self, args): - return self.invoke_with(args, self) + def invoke_k(self, args, stack): + return self.invoke_k_with(args, stack, self) - def invoke_with(self, args, self_fn): - return self.get_fn(len(args)).invoke_with(args, self_fn) + def invoke_k_with(self, args, stack, self_fn): + return self.get_fn(len(args)).invoke_k_with(args, stack, self_fn) class NativeFn(BaseCode): @@ -298,24 +299,25 @@ def name(self): def required_arity(self): return self._required_arity - def invoke(self, args): - return self.invoke_with(args, self) + def invoke_k(self, args, stack): + return self.invoke_k_with(args, stack, self) - def invoke_with(self, args, self_fn): - from pixie.vm2.array import array + def invoke_k_with(self, args, stack, this_fn): + from pixie.vm2.array import Array argc = len(args) if self._required_arity == 0: - return self._code.invoke_with([array(args)], self_fn) + return self._code.invoke_k([Array(args)], stack) if argc == self._required_arity: new_args = resize_list(args, len(args) + 1) - new_args[len(args)] = array([]) - return self._code.invoke_with(new_args, self_fn) + new_args[len(args)] = Array([]) + return self._code.invoke_k_with(new_args, stack, this_fn) elif argc > self._required_arity: start = slice_from_start(args, self._required_arity, 1) rest = slice_to_end(args, self._required_arity) - start[self._required_arity] = array(rest) - return self._code.invoke_with(start, self_fn) + start[self._required_arity] = Array(rest) + return self._code.invoke_k_with(start, stack, this_fn) affirm(False, u"Got " + unicode(str(argc)) + u" arg(s) need at least " + unicode(str(self._required_arity))) + return None, stack class Closure(BaseCode): diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 77ec2beb..0151b756 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -23,6 +23,9 @@ def call_continuation(self, val, stack): ast = jit.promote(self._c_ast) return ast.interpret(val, self._c_locals, stack) + def get_ast(self): + return self._c_ast + class Const(AST): _immutable_fields_ = ["_c_val"] _type = Type(u"pixie.interpreter.Const") @@ -73,25 +76,30 @@ def interpret(self, _, locals, stack): return InterpretedFn(self._c_name, self._c_args, self._c_body), stack class InterpretedFn(code.BaseCode): - _immutable_fields_ = ["_c_arg_names", "_c_locals", "_c_fn_ast"] + _immutable_fields_ = ["_c_arg_names", "_c_locals", "_c_fn_ast", "_c_name"] def __init__(self, name, arg_names, ast): self._c_arg_names = arg_names + self._c_name = name if name is not nil: self._c_locals = Locals(name, self, None) else: self._c_locals = None self._c_fn_ast = ast - @jit.unroll_safe def invoke_k(self, args, stack): + return self.invoke_k_with(args, stack, self) + + @jit.unroll_safe + def invoke_k_with(self, args, stack, self_fn): # TODO: Check arg count - locals = jit.promote(self._c_locals) + locals = Locals(self._c_name, self_fn, None) for idx in range(len(self._c_arg_names)): locals = Locals(self._c_arg_names[idx], args[idx], locals) return nil, stack_cons(stack, InterpretK(self._c_fn_ast, locals)) + class Invoke(AST): _immutable_fields_ = ["_c_args", "_c_fn"] def __init__(self, args, meta=nil): @@ -115,6 +123,9 @@ def call_continuation(self, val, stack): args = val._list[1:] return fn.invoke_k(args, stack) + def get_ast(self): + return self._c_ast + class TailCall(AST): @@ -135,6 +146,9 @@ class TailCallK(InvokeK): def __init__(self, ast): InvokeK.__init__(self, ast) + def get_ast(self): + return self._c_ast + class ResolveAllK(Continuation): _immutable_ = True def __init__(self, args, locals, acc): @@ -159,6 +173,9 @@ def call_continuation(self, val, stack): return val, stack + def get_ast(self): + return self._c_args[len(self._c_acc)] + @@ -190,6 +207,9 @@ def call_continuation(self, val, stack): stack = stack_cons(stack, InterpretK(ast._c_then, self._c_locals)) return nil, stack + def get_ast(self): + return self._c_ast + class Do(AST): _immutable_fields_ = ["_c_body_asts"] @@ -199,25 +219,29 @@ def __init__(self, args, meta=nil): @jit.unroll_safe def interpret(self, val, locals, stack): - return val, stack_cons(stack, DoK(self._c_body_asts, locals)) + return val, stack_cons(stack, DoK(self, self._c_body_asts, locals)) class DoK(Continuation): _immutable_ = True - def __init__(self, do_asts, locals, idx=0): + def __init__(self, ast, do_asts, locals, idx=0): + self._c_ast = ast self._c_locals = locals self._c_body_asts = do_asts self._c_idx = idx def call_continuation(self, val, stack): if self._c_idx + 1 < len(self._c_body_asts): - stack = stack_cons(stack, DoK(self._c_body_asts, self._c_locals, self._c_idx + 1)) + stack = stack_cons(stack, DoK(self._c_ast, self._c_body_asts, self._c_locals, self._c_idx + 1)) stack = stack_cons(stack, InterpretK(self._c_body_asts[self._c_idx], self._c_locals)) return nil, stack else: stack = stack_cons(stack, InterpretK(self._c_body_asts[self._c_idx], self._c_locals)) return nil, stack + def get_ast(self): + return self._c_ast + class VDeref(AST): _immutable_fields_ = ["_c_var"] def __init__(self, var, meta=nil): @@ -225,4 +249,5 @@ def __init__(self, var, meta=nil): self._c_var = var def interpret(self, val, locals, stack): - return self._c_var.deref(), stack \ No newline at end of file + return self._c_var.deref(), stack + diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index 2715c14f..9806d46b 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -118,6 +118,10 @@ class Continuation(object): def call_continuation(self, val, stack): return None, stack + def get_ast(self): + from pixie.vm2.primitives import nil + return nil + class StackCell(object): """Defines an immutable call stack, stacks can be copied, spliced and combined""" @@ -131,18 +135,25 @@ def stack_cons(stack, other): from rpython.rlib.jit import JitDriver -jitdriver = JitDriver(greens=[], reds=["stack", "val"]) +jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"]) def run_stack(val, cont, stack=None): - stack = StackCell(cont, stack) + stack = None val = None - while stack is not None: - jitdriver.jit_merge_point(stack=stack, val=val) + ast = cont.get_ast() + while True: + jitdriver.jit_merge_point(ast=ast, stack=stack, val=val, cont=cont) + val, stack = cont.call_continuation(val, stack) + if stack is None: + return val + old_cont = cont + old_ast = old_cont.get_ast() cont = stack._cont + ast = cont.get_ast() stack = stack._parent - val, stack = cont.call_continuation(val, stack) - if stack is not None and stack._cont.should_enter_jit: - jitdriver.can_enter_jit(stack=stack, val=val) + #print ast + if old_cont.should_enter_jit: + jitdriver.can_enter_jit(ast=old_ast, stack=stack, val=val, cont=cont) return val @@ -155,7 +166,7 @@ def affirm(f, msg): print msg raise NotImplementedError() -def runtime_error(msg): +def runtime_error(msg, kw=None): raise NotImplementedError() class WrappedException(BaseException): diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index 6352f114..85858f65 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -2,7 +2,7 @@ from pixie.vm2.object import Object, Type, affirm from pixie.vm2.code import extend, as_var, wrap_fn from pixie.vm2.primitives import nil, true, false -from pixie.vm2.numbers import Integer, _add +from pixie.vm2.numbers import Integer #import pixie.vm2.stdlib as proto #import pixie.vm2.util as util from rpython.rlib.rarithmetic import intmask, r_uint diff --git a/target.py b/target.py index 66f397c5..b34154fc 100644 --- a/target.py +++ b/target.py @@ -91,7 +91,7 @@ def inner_invoke(self, args): if newline_pos > 0: data = data[newline_pos:] - rt.load_reader(StringReader(unicode_from_utf8(data))) + rt.load_reader(MetaDataReader(StringReader(unicode_from_utf8(data)), unicode(self._file))) except WrappedException as ex: print "Error: ", ex._ex.__repr__() os._exit(1) diff --git a/target2.py b/target2.py index e0da79c5..3613209c 100644 --- a/target2.py +++ b/target2.py @@ -5,16 +5,19 @@ import pixie.vm2.code as code from pixie.vm2.keyword import keyword as kw from pixie.vm2.symbol import symbol as sym +from pixie.vm2.numbers import parse_number rt.init() +with open("/tmp/pxi.py") as f: + pixie_code = eval(f.read()) + + def testit(max): - with open("/tmp/pxi.py") as f: - c = eval(f.read()) - return run_stack(None, i.InterpretK(c, None)) + return run_stack(None, i.InterpretK(pixie_code, None)) #val = testit() #print val.int_val(), val @@ -22,6 +25,7 @@ def testit(max): def entry_point(): #s = rt.wrap(u"Foo") from pixie.vm2.string import String + v = parse_number(u"1") s = String(u"Foo") max = 10000 #int(args[1]) @@ -87,7 +91,11 @@ def run_debug(argv): class DebugIFace(JitHookInterface): def on_abort(self, reason, jitdriver, greenkey, greenkey_repr, logops, operations): - # print "Aborted Trace, reason: ", Counters.counter_names[reason], logops, greenkey_repr + print "Aborted Trace, reason: ", Counters.counter_names[reason], logops, greenkey_repr + pass + + def before_compile_bridge(self, debug_info): + print "Compiling Bridge", debug_info pass import sys, pdb @@ -115,5 +123,5 @@ def target(*args): print rpython.config.translationoption.get_combined_translation_config() if __name__ == "__main__": - #run_debug(sys.argv) - entry_point() + run_debug(sys.argv) + #entry_point() From b5d2544ebe26e6aca5b021239d8896d9d97c861f Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 11 May 2015 21:24:34 -0600 Subject: [PATCH 05/46] added metadata and closures to both the jit and the compiler --- pixie/compiler.pxi | 101 ++++++++++++++++++++++++++------------- pixie/vm2/interpreter.py | 49 ++++++++++++++----- pixie/vm2/object.py | 18 ++++--- target2.py | 5 +- 4 files changed, 120 insertions(+), 53 deletions(-) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 8c5bd119..68722ab0 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -16,7 +16,6 @@ (set-dynamic! (var *env*)) (defmulti analyze-form (fn [x] - (println "Meta --> " (meta x)) (cond (nil? x) nil (seq? x) :seq @@ -84,7 +83,13 @@ (let [[args variadic?] (let [not& (vec (filter (complement (partial = '&)) args))] [not& (= '& (last (butlast args)))]) arity (count args) - new-env (assoc-in *env* [:locals fn-name] {:op :binding + new-env (update-in *env* [:locals] (fn [locals] + (reduce + (fn [locals [k v]] + (assoc locals k (assoc v :closed-overs #{k}))) + {} + locals))) + new-env (assoc-in new-env [:locals fn-name] {:op :binding :type :fn-self :name fn-name :form fn-name @@ -175,10 +180,8 @@ (defmethod analyze-seq :default [[sym & args :as form]] - (println form) (let [resolved (and (symbol? sym) (resolve-in (the-ns (:ns *env*)) sym))] - (println "fff" (contains? macro-overrides resolved)) (cond (and resolved (contains? macro-overrides resolved)) @@ -230,12 +233,11 @@ (if-let [local (get-in *env* [:locals x])] (if (= (:op local) :local-macro) (analyze-form (:replace-with local)) - local) + (assoc local :form x)) (maybe-var x))) (defmethod analyze-form :vector [x] - (println "analyze " x) {:op :vector :children [:items] :items (mapv analyze-form x) @@ -285,32 +287,53 @@ -(defn walk [post pre selector node] +(defn walk [pre post selector node] (-> (reduce (fn [node k] (let [v (get node k) result (if (or (vector? v) (seq? v)) - (mapv (partial walk post pre selector) v) - (walk post pre selector v))] + (mapv (partial walk pre post selector) v) + (walk pre post selector v))] (assoc node k result))) (pre node) (selector node)) post)) (defn post-walk [f ast] - (walk f identity :children ast)) + (walk identity f :children ast)) (defn clean-do [ast] (post-walk - (fn [{:keys [op statements ret] :as do}] - (println ">-- " op (count statements)) + (fn [{:keys [op statements ret] :as ast}] (if (and (= op :do) (= (count statements) 0)) - (do (println "reducing ") ret) + ret ast)) ast)) +(defn child-seq [ast] + (mapcat + (fn [k] + (let [child (get ast k)] + (if (or (vector? child) + (seq? child)) + child + [child]))) + (:children ast))) + +(defn collect-closed-overs [ast] + (post-walk + (fn [{:keys [op args env closed-overs] :as ast}] + (let [{:keys [locals]} env + closed-overs (set (or closed-overs + (mapcat :closed-overs (child-seq ast)))) + closed-overs (if (= op :fn-body) + (reduce disj closed-overs args) + closed-overs)] + (assoc ast :closed-overs closed-overs))) + ast)) + (defn remove-env [ast] (walk #(dissoc % :env) identity @@ -324,21 +347,20 @@ (defn add-meta [{:keys [meta-state meta-lines] :as state} ast] (let [m (meta (:form ast))] (if m - (let [k [(:line m) (:file m)] + (let [k [(:line m) (:file m) (:line-number m)] id (get @meta-state k)] (if id id (let [id (str "mid" (count @meta-state))] (swap! meta-state assoc k id) - (swap! meta-lines conj! (str id " = (u\"" (:line m) "\", \"" (:file m) "\")\n")) + (swap! meta-lines conj! (str id " = (u\"" (:line m) "\", \"" (:file m) "\", " (:line-number m) ")\n")) id))) "nil"))) (defn meta-str [state ast] - (println (:form ast) (meta (:form ast))) (let [m (meta (:form ast))] (if m - (str "Meta(" (add-meta state ast) ", " (:line-number m) ", " (:column-number m) ")") + (str "i.Meta(" (add-meta state ast) ", " (:column-number m) ")") "nil"))) (defn offset-spaces [sb off] @@ -346,7 +368,6 @@ (write! sb " "))) (defmulti to-rpython (fn [sb offset node] - (println (:op node)) (:op node))) (defmethod to-rpython :if @@ -369,7 +390,6 @@ (write! sb ")"))) (defmulti write-const (fn [sb offset const] - (println "const " const) (:type const))) (defmethod write-const :keyword @@ -426,9 +446,11 @@ (to-rpython sb offset x) (write! sb ",\n"))) (offset-spaces sb offset) - (write! sb "],\n")) - (offset-spaces sb offset) - (write! sb ")")) + (write! sb "],\n") + (offset-spaces sb offset) + (write! sb "meta=") + (write! sb (meta-str sb ast)) + (write! sb ")"))) (defmethod to-rpython :do @@ -474,19 +496,29 @@ (write! sb "])")))) (defn to-rpython-fn-body - [sb offset name {:keys [args body variadic?]}] + [sb offset name {:keys [args body variadic? closed-overs]}] + (println "FN: - " closed-overs) (when variadic? (write! sb (str "i.Invoke([i.Const(code.intern_var(u\"pixie.stdlib\", u\"variadic-fn\")), i.Const(rt.wrap(" (dec (count args)) ")), \n")) (offset-spaces sb offset)) (write! sb "i.Fn(args=[") (write! sb (->> args (map (fn [name] - (str "kw(u\"" name "\")"))) + (str "kw(u\"" name "\")"))) (interpose ",") (apply str))) (write! sb "],name=kw(u\"") (write! sb (str name)) - (write! sb "\"),\n") + (write! sb "\"),") + (when (not (empty? closed-overs)) + (write! sb "closed_overs=[") + (write! sb (->> closed-overs + (map (fn [name] + (str "kw(u\"" name "\")"))) + (interpose ",") + (apply str))) + (write! sb "],")) + (write! sb "\n") (let [offset (inc offset)] (offset-spaces sb offset) (write! sb "body=") @@ -498,19 +530,23 @@ (write! sb "])"))) (defmethod to-rpython :var - [sb offset {:keys [ns name]}] + [sb offset {:keys [ns name] :as ast}] (write! sb "i.VDeref(code.intern_var(") (write! sb "u\"") (write! sb ns) (write! sb "\", u\"") (write! sb name) - (write! sb "\"))")) + (write! sb "\"), meta=") + (write! sb (meta-str sb ast)) + (write! sb ")")) (defmethod to-rpython :binding - [sb offset {:keys [name]}] + [sb offset {:keys [name] :as ast}] (write! sb "i.Lookup(kw(u\"") (write! sb name) - (write! sb "\"))")) + (write! sb "\"), meta=") + (write! sb (meta-str sb ast)) + (write! sb ")")) (defmethod to-rpython :def [sb offset {:keys [name env val]}] @@ -552,6 +588,7 @@ (defn finish-context [{:keys [meta-lines code]}] (str (string-builder @meta-lines) "\n \n" + "code_ast=" (string-builder @code))) (let [form @@ -564,10 +601,10 @@ ((fn c [i max] (if (-lt i max) - (c (+ i 1 1) max) - max)) + (c (-add ((fn [] i)) ((fn [] 1))) max) + i)) 0 10000)) - str (finish-context (to-rpython (writer-context) 0 (clean-do (analyze form))))] + str (finish-context (to-rpython (writer-context) 0 (collect-closed-overs (clean-do (analyze form)))))] (print str) (io/spit "/tmp/pxi.py" str)) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 0151b756..0d353971 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -8,10 +8,29 @@ class AST(Object): _immutable_fields_ = ["_c_meta"] - should_enter_jit = False def __init__(self, meta): self._c_meta = meta + def get_short_location(self): + if self._c_meta != nil: + return self._c_meta.get_short_location() + return "" + +class Meta(Object): + _type = Type(u"pixie.stdlib.Meta") + _immutable_fields_ = ["_c_column_number", "_c_line_tuple"] + def __init__(self, line_tuple, column_number): + self._c_column_number = column_number + self._c_line_tuple = line_tuple + + def get_short_location(self): + (line, file, line_number) = self._c_line_tuple + + return str(file) + " @ " + str(line[:self._c_column_number]) + "^" + str(line[self._c_column_number:]) + +class PrevASTNil(AST): + def __init__(self): + AST.__init__(self, nil) class InterpretK(Continuation): _immutable_ = True @@ -65,25 +84,30 @@ def interpret(self, _, locals, stack): class Fn(AST): _immutable_fields_ = ["_c_name", "_c_args", "_c_body", "_c_closed_overs"] - def __init__(self, name, args, body, meta=nil): + def __init__(self, name, args, body, closed_overs=[], meta=nil): AST.__init__(self, meta) self._c_name = name self._c_args = args self._c_body = body + self._c_closed_overs = closed_overs @jit.unroll_safe def interpret(self, _, locals, stack): - return InterpretedFn(self._c_name, self._c_args, self._c_body), stack + locals_prefix = None + for n in self._c_closed_overs: + locals_prefix = Locals(n, Locals.get_local(locals, n), locals_prefix) + + return InterpretedFn(self._c_name, self._c_args, locals_prefix, self._c_body), stack class InterpretedFn(code.BaseCode): - _immutable_fields_ = ["_c_arg_names", "_c_locals", "_c_fn_ast", "_c_name"] - def __init__(self, name, arg_names, ast): + _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name"] + def __init__(self, name, arg_names, locals_prefix, ast): self._c_arg_names = arg_names self._c_name = name if name is not nil: - self._c_locals = Locals(name, self, None) + self._c_locals = Locals(name, self, locals_prefix) else: - self._c_locals = None + self._c_locals = locals_prefix self._c_fn_ast = ast def invoke_k(self, args, stack): @@ -92,9 +116,10 @@ def invoke_k(self, args, stack): @jit.unroll_safe def invoke_k_with(self, args, stack, self_fn): # TODO: Check arg count - locals = Locals(self._c_name, self_fn, None) - for idx in range(len(self._c_arg_names)): - locals = Locals(self._c_arg_names[idx], args[idx], locals) + locals = Locals(jit.promote(self._c_name), self_fn, self._c_locals) + arg_names = jit.promote(self._c_arg_names) + for idx in range(len(arg_names)): + locals = Locals(arg_names[idx], args[idx], locals) return nil, stack_cons(stack, InterpretK(self._c_fn_ast, locals)) @@ -171,7 +196,7 @@ def call_continuation(self, val, stack): else: return Array(self.append_to_acc(val)), stack - return val, stack + return nil, stack def get_ast(self): return self._c_args[len(self._c_acc)] @@ -219,7 +244,7 @@ def __init__(self, args, meta=nil): @jit.unroll_safe def interpret(self, val, locals, stack): - return val, stack_cons(stack, DoK(self, self._c_body_asts, locals)) + return nil, stack_cons(stack, DoK(self, self._c_body_asts, locals)) class DoK(Continuation): diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index 9806d46b..65f58948 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -133,27 +133,31 @@ def __init__(self, cont, parent_stack): def stack_cons(stack, other): return StackCell(other, stack) +def get_printable_location(ast, old_ast): + return ast.get_short_location() from rpython.rlib.jit import JitDriver -jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"]) +jitdriver = JitDriver(greens=["ast", "prev_ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) def run_stack(val, cont, stack=None): + from pixie.vm2.interpreter import PrevASTNil stack = None val = None ast = cont.get_ast() + prev_ast = PrevASTNil() while True: - jitdriver.jit_merge_point(ast=ast, stack=stack, val=val, cont=cont) + jitdriver.jit_merge_point(ast=ast, prev_ast=prev_ast, stack=stack, val=val, cont=cont) val, stack = cont.call_continuation(val, stack) if stack is None: return val - old_cont = cont - old_ast = old_cont.get_ast() + prev_ast = ast + prev_cont = cont cont = stack._cont ast = cont.get_ast() stack = stack._parent - #print ast - if old_cont.should_enter_jit: - jitdriver.can_enter_jit(ast=old_ast, stack=stack, val=val, cont=cont) + + if prev_cont.should_enter_jit: + jitdriver.can_enter_jit(ast=ast, prev_ast=prev_ast, stack=stack, val=val, cont=cont) return val diff --git a/target2.py b/target2.py index 3613209c..5ade8d8e 100644 --- a/target2.py +++ b/target2.py @@ -2,6 +2,7 @@ import pixie.vm2.interpreter as i from pixie.vm2.object import StackCell, run_stack import pixie.vm2.rt as rt +from pixie.vm2.primitives import nil import pixie.vm2.code as code from pixie.vm2.keyword import keyword as kw from pixie.vm2.symbol import symbol as sym @@ -10,8 +11,8 @@ rt.init() with open("/tmp/pxi.py") as f: - pixie_code = eval(f.read()) - + exec f.read() + pixie_code = code_ast def testit(max): From fd1866957e9d228f8f86ee6c6947738dce232422 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 12 May 2015 06:57:24 -0600 Subject: [PATCH 06/46] started working on bootstrap.pxi --- pixie/bootstrap.pxi | 147 ++++++++++++++++++++++++++++++++++++++++++++ pixie/compiler.pxi | 51 ++++++++++----- pixie/vm/stdlib.py | 2 +- target2.py | 4 +- 4 files changed, 184 insertions(+), 20 deletions(-) create mode 100644 pixie/bootstrap.pxi diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi new file mode 100644 index 00000000..57837e94 --- /dev/null +++ b/pixie/bootstrap.pxi @@ -0,0 +1,147 @@ +;; This file is used to build what we need to even start running stdlib.pxi +;; Ordering of stuff will probably matter here + +(defprotocol ISeq + (-first [this]) + (-next [this])) + +(defprotocol ISeqable + (-seq [this])) + +(defprotocol ICounted + (-count [this])) + +(defprotocol IIndexed + (-nth [this idx]) + (-nth-not-found [this idx not-found])) + + +(defprotocol IPersistentCollection + (-conj [this x]) + (-disj [this x])) + +(defprotocol IEmpty + (-empty [this])) + +(defprotocol IObject + (-hash [this]) + (-eq [this other]) + (-str [this]) + (-repr [this])) + +(defprotocol IReduce + (-reduce [this f init])) + +(defprotocol IDeref + (-deref [this])) + +(defprotocol IReset + (-reset! [this val])) + +(defprotocol INamed + (-namespace [this]) + (-name [this])) + +(defprotocol IAssociative + (-assoc [this k v]) + (-contains-key [this k]) + (-dissoc [this k])) + +(defprotocol ILookup + (-get [this])) + +(defprotocol IMapEntry + (-key [this]) + (-val [this])) + +(defprotocol IStack + (-push [this v])) + +(defprotocol IPop + (-pop [this])) + +(defprotocol IFn + (-invoke [this args])) + +(defprotocol IDoc + (-doc [this])) + +(defprotocol IVector) +(defprotocol ISequential) +(defprotocol IMap) + +(defprotocol IMeta + (-with-meta [this x]) + (-meta [this])) + +(defprotocol ITransientCollection + (-conj! [this x])) + +(defprotocol ITransientStack + (-push! [this x]) + (-pop! [this])) + +(defprotocol IDisposable + (-dispose! [this])) + +(defprotocol IOpaqueObject + (-get-field [this name]) + (-invoke-method [this name args])) + +(comment + (deftype Cons [first next meta] + ISeq + (-first [this] first) + (-next [this] next) + ISeqable + (-seq [this] this) + IMeta + (-meta [this] meta) + (-with-meta [this new-meta] + (->Cons first next new-meta))) + + (defn cons [head tail] + (->Cons head (seq tail) nil)) + + (defn + + ([] 0) + ([x] x) + ([x y] (-add x y)) + ([x y & more] + (-apply + (+ x y) more)))) + + +;; PersistentVector + +(comment + (deftype PersistentVectorNode [edit array]) + + (defn persistent-vector-node + ([edit] + (persistent-vector-node edit (array 32))) + ([edit array] + (->PersistentVectorNode edit array))) + + (def EMPTY_NODE (persistent-vector-node nil)) + + +) + +(defn tailoff [this] + (let [cnt (.-cnt this)] + (if (< cnt 32) + 0 + (bit-shift-left (bit-shift-right (dec cnt) 5) 5)))) + +(defn array-for [this i cnt root shift tail] + (if (and (<= 0 i) (< i cnt)) + (if (>= i (tailoff this)) + tail + (.-array ((fn look-deeper [node level] + (if (> level 0) + (look-deeper (aget (:array node) + (bit-and (bit-shift-right i level) 0x01f)) + (- level 5)) + (:array node))) + root + shift))))) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 68722ab0..9b650652 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -1,5 +1,6 @@ (ns pixie.compiler - (:require [pixie.io :as io])) + (:require [pixie.io :as io] + [pixie.string :as string])) (def macro-overrides { @@ -44,6 +45,13 @@ (mapv analyze-form (butlast (next x)))) :ret (analyze-form (last x))}) +(defmethod analyze-seq 'comment + [x] + {:op :const + :type (keyword "nil") + :form x + :env *env*}) + (defmethod analyze-seq 'if [[_ test then else :as form]] {:op :if @@ -183,6 +191,23 @@ (let [resolved (and (symbol? sym) (resolve-in (the-ns (:ns *env*)) sym))] (cond + (and (symbol? sym) + (string/starts-with? (name sym) ".-")) + (let [sym-kw (keyword (string/substring (name sym) 2))] + {:op :invoke + :tail-call (:tail? *env*) + :children '[:fn :args] + :form form + :env *env* + :fn {:op :var + :env *env* + :ns (:ns *env*) + :name 'pixie.stdlib/-get-field + :form 'pixie.stdlib/-get-field} + :args (binding [*env* (assoc *env* :tail? false)] + (mapv analyze-form (cons sym-kw args)))}) + + (and resolved (contains? macro-overrides resolved)) (analyze-form (apply (macro-overrides resolved) args)) @@ -279,9 +304,12 @@ :tail? true}) -(defn analyze [form] - (binding [*env* (new-env)] - (analyze-form form))) +(defn analyze + ([form] + (analyze form (new-env))) + ([form env] + (binding [*env* env] + (analyze-form form)))) @@ -368,6 +396,7 @@ (write! sb " "))) (defmulti to-rpython (fn [sb offset node] + (println (:op node) (:form node)) (:op node))) (defmethod to-rpython :if @@ -591,19 +620,7 @@ "code_ast=" (string-builder @code))) -(let [form - '(do (defn + - ([] 0) - ([x] x) - ([x y] (-add x y)) - ([x y & more] - (-apply + (+ x y) more))) - - ((fn c [i max] - (if (-lt i max) - (c (-add ((fn [] i)) ((fn [] 1))) max) - i)) - 0 10000)) +(let [form (read-string (str "(do " (pixie.io/slurp "pixie/bootstrap.pxi") ")")) str (finish-context (to-rpython (writer-context) 0 (collect-closed-overs (clean-do (analyze form)))))] (print str) (io/spit "/tmp/pxi.py" str)) diff --git a/pixie/vm/stdlib.py b/pixie/vm/stdlib.py index bcb43428..af5adc32 100644 --- a/pixie/vm/stdlib.py +++ b/pixie/vm/stdlib.py @@ -336,7 +336,7 @@ def _satisfies(proto, o): @as_var("read-string") def _read_string(s): import pixie.vm.reader as reader - return reader.read(reader.StringReader(unicode(rt.name(s))), True) + return reader.read(reader.MetaDataReader(reader.StringReader(unicode(rt.name(s)))), True) # XXX seems broken under jit. @as_var("eval") diff --git a/target2.py b/target2.py index 5ade8d8e..ec718623 100644 --- a/target2.py +++ b/target2.py @@ -124,5 +124,5 @@ def target(*args): print rpython.config.translationoption.get_combined_translation_config() if __name__ == "__main__": - run_debug(sys.argv) - #entry_point() + #run_debug(sys.argv) + entry_point() From 173c46d689aa58362c7fa380df4e23e2ebf96a50 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Wed, 13 May 2015 16:52:58 -0600 Subject: [PATCH 07/46] started writing PersistentVectors in pixie, added let support --- pixie/bootstrap.pxi | 167 +++++++++++++++++++++++++++++++-------- pixie/compiler.pxi | 147 +++++++++++++++++++++++++++------- pixie/vm2/interpreter.py | 32 ++++++++ pixie/vm2/rt.py | 27 +------ 4 files changed, 287 insertions(+), 86 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 57837e94..dd2e10dd 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -84,48 +84,88 @@ (defprotocol IDisposable (-dispose! [this])) -(defprotocol IOpaqueObject +(defprotocol IMessageObject (-get-field [this name]) (-invoke-method [this name args])) -(comment - (deftype Cons [first next meta] - ISeq - (-first [this] first) - (-next [this] next) - ISeqable - (-seq [this] this) - IMeta - (-meta [this] meta) - (-with-meta [this new-meta] - (->Cons first next new-meta))) - - (defn cons [head tail] - (->Cons head (seq tail) nil)) - - (defn + - ([] 0) - ([x] x) - ([x y] (-add x y)) - ([x y & more] - (-apply + (+ x y) more)))) +;; Math wrappers + +(extend -eq Number -num-eq) + +(defn + + {:doc "Adds the arguments, returning 0 if no arguments" + :signatures [[& args]] + :added "0.1"} + ([] 0) + ([x] x) + ([x y] (-add x y)) + ([x y & more] + (-apply + (+ x y) more))) + +(defn - + ([] 0) + ([x] x) + ([x y] (-sub x y)) + ([x y & more] + (-apply - (- x y) more))) + +(defn inc + ([x] (+ x 1))) + +(defn dec + ([x] (- x 1))) + +(defn < + ([x y] (-lt x y)) + ([x y & more] + (-apply < (< x y) more))) + +(defn = + {:doc "Returns true if all the arguments are equivalent. Otherwise, returns false. Uses +-eq to perform equality checks." + :signatures [[& args]] + :added "0.1"} + ([x] true) + ([x y] (if (identical? x y) + true + (-eq x y))) + ([x y & rest] (if (eq x y) + (apply = y rest) + false))) + + +(deftype Cons [first next meta] + ISeq + (-first [this] first) + (-next [this] next) + ISeqable + (-seq [this] this) + IMeta + (-meta [this] meta) + (-with-meta [this new-meta] + (->Cons first next new-meta))) + +(defn cons [head tail] + (->Cons head (seq tail) nil)) + ;; PersistentVector -(comment - (deftype PersistentVectorNode [edit array]) +(deftype Node [edit array] + IMessageObject + (-get-field [this name] + (get-field this name))) - (defn persistent-vector-node - ([edit] - (persistent-vector-node edit (array 32))) - ([edit array] - (->PersistentVectorNode edit array))) +(defn new-node + ([edit] + (new-node edit (array 32))) + ([edit array] + (->Node edit array))) + +(def EMPTY-NODE (new-node nil)) - (def EMPTY_NODE (persistent-vector-node nil)) - -) (defn tailoff [this] (let [cnt (.-cnt this)] @@ -145,3 +185,66 @@ (:array node))) root shift))))) + +(deftype PersistentVector [cnt shift root tail meta] + IMessageObject + (-get-field [this name] + (get-field this name)) + + IPersistentCollection + (-conj [this val] + (assert (< cnt 0xFFFFFFFF) "Vector too large") + + (if (< (- cnt (tailoff self)) 32) + (let [new-tail (array-append tail val)] + (->PersistentVector (inc cnt) shift root new-tail meta)) + (let [tail-node (->Node (.-edit root) tail)] + (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift)) + (let [new-root (new-node (.-edit root))] + (aset new-root 0 root) + (aset new-root 1 (new-path (.-edit root) shift tail-node)) + (->PersistentVector (inc cnt) + (+ shift 5) + new-root + (array val) + meta)) + (let [new-root (push-tail this shift root tail-node)] + (->PersistentVector (inc cnt) + shift + new-root + (array val) + meta)))))) + + ICounted + (-count [this] cnt)) + + +(defn push-tail [this level parent tail-node] + (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f) + ret-array (aclone (.-array parent)) + node-to-insert (if (= level 5) + tail-node + (let [child (aget (.-array parent) subidx)] + (if (= child nil) + (new-path (.-edit (.-root this)) + (- level 5) + tail-node) + (push-tail this + (- level 5) + child + tail-node))))] + (aset ret-array subidx node-to-insert) + (->Node (.-edit parent) node-to-insert))) + +(defn new-path [edit level node] + (if (= level 0) + node + (->Node edit + (new-path edit (- level 5) node)))) + + +(def EMPTY (->PersistentVector nil 0 5 EMPTY-NODE (array 0))) + + +(let [x 4] + (+ x 1)) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 9b650652..bd8638ef 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -10,7 +10,69 @@ `(do (def ~nm (protocol ~(str nm))) ~@(map (fn [[x]] `(def ~x (polymorphic-fn ~(str x) ~nm))) - sigs)))}) + sigs))) + + (resolve 'deftype) + (fn deftype + [nm fields & body] + (let [ctor-name (symbol (str "->" (name nm))) + fields (transduce (map (comp keyword name)) conj fields) + field-syms (transduce (map (comp symbol name)) conj fields) + mk-body (fn [body] + (let [fn-name (first body) + _ (assert (symbol? fn-name) "protocol override must have a name") + args (second body) + _ (assert (or (vector? args) + (seq? args)) "protocol override must have arguments") + self-arg (first args) + _ (assert (symbol? self-arg) "protocol override must have at least one `self' argument") + + rest (next (next body)) + body (reduce + (fn [body f] + `[(local-macro [~(symbol (name f)) + (get-field ~self-arg ~(keyword (name f)))] + ~@body)]) + rest + fields)] + `(fn ~(symbol (str fn-name "_" nm)) ~args ~@body))) + bodies (reduce + (fn [res body] + (cond + (symbol? body) (cond + (= body 'Object) [body (second res) (third res)] + :else [body + (second res) + (conj (third res) body)]) + (seq? body) (let [proto (first res) tbs (second res) pbs (third res)] + (if (protocol? proto) + [proto tbs (conj pbs body)] + [proto (conj tbs body) pbs])))) + [nil [] []] + body) + type-bodies (second bodies) + proto-bodies (third bodies) + all-fields (reduce (fn [r tb] (conj r (keyword (name (first tb))))) fields type-bodies) + type-decl `(def ~nm (create-type ~(keyword (name nm)) ~all-fields)) + inst (gensym) + ctor `(defn ~ctor-name ~field-syms + (new ~nm + ~@field-syms + ~@(transduce (map (fn [type-body] + (mk-body type-body))) + conj + type-bodies))) + proto-bodies (transduce + (map (fn [body] + (cond + (symbol? body) `(satisfy ~body ~nm) + (seq? body) `(extend ~(first body) ~nm ~(mk-body body)) + :else (assert false "Unknown body element in deftype, expected symbol or seq")))) + conj + proto-bodies)] + `(do ~type-decl + ~ctor + ~@proto-bodies)))}) (def *env* nil) @@ -123,6 +185,14 @@ :body (binding [*env* (assoc new-env :tail? true)] (analyze-form (cons 'do body)))}))) +(defn analyze-let-body + [acc [name binding & rest :as form]] + {:op :let + :form form + :children '[:binding :body] + :env *env* + :name name + :body acc}) (defmethod analyze-seq 'let* [[_ bindings & body :as form]] @@ -133,7 +203,7 @@ (let [binding-ast (binding [*env* new-env] {:op :binding :type :let - :children [:value] + :children '[:value] :form binding-form :env *env* :name name @@ -145,7 +215,7 @@ parted)] {:op :let :form form - :children [:bindings :body] + :children '[:bindings :body] :bindings bindings :env *env* :body (binding [*env* new-env] @@ -159,7 +229,7 @@ :name nm :form form :env *env* - :children [:val] + :children '[:val] :val (analyze-form val)}) (defmethod analyze-seq 'quote @@ -381,7 +451,7 @@ id (let [id (str "mid" (count @meta-state))] (swap! meta-state assoc k id) - (swap! meta-lines conj! (str id " = (u\"" (:line m) "\", \"" (:file m) "\", " (:line-number m) ")\n")) + (swap! meta-lines conj! (str id " = (u\"\"\"" (:line m) "\"\"\", \"" (:file m) "\", " (:line-number m) ")\n")) id))) "nil"))) @@ -396,7 +466,7 @@ (write! sb " "))) (defmulti to-rpython (fn [sb offset node] - (println (:op node) (:form node)) + (assert node) (:op node))) (defmethod to-rpython :if @@ -516,17 +586,17 @@ (write! sb ",\n"))) (offset-spaces sb offset) (let [vfn (first (filter :variadic? arities))] - (offset-spaces sb offset) - (write! sb (str "i.Const(rt.wrap(-1)), \n")) - (offset-spaces sb offset) - (to-rpython-fn-body sb offset name vfn) - (write! sb "\n"))) + (when vfn + (offset-spaces sb offset) + (write! sb (str "i.Const(rt.wrap(-1)), \n")) + (offset-spaces sb offset) + (to-rpython-fn-body sb offset name vfn) + (write! sb "\n")))) (offset-spaces sb offset) (write! sb "])")))) (defn to-rpython-fn-body - [sb offset name {:keys [args body variadic? closed-overs]}] - (println "FN: - " closed-overs) + [sb offset name {:keys [args body variadic? closed-overs] :as ast}] (when variadic? (write! sb (str "i.Invoke([i.Const(code.intern_var(u\"pixie.stdlib\", u\"variadic-fn\")), i.Const(rt.wrap(" (dec (count args)) ")), \n")) (offset-spaces sb offset)) @@ -608,6 +678,40 @@ (offset-spaces sb offset) (write! sb "])"))) +(defmethod to-rpython :let + [sb offset {:keys [bindings body] :as ast}] + (write! sb "i.Let(names=[") + (write! sb (->> bindings + (map (fn [binding] + (str "kw(u\"" (:name binding) "\")"))) + (interpose ",") + (apply str))) + (write! sb "],\n") + + (offset-spaces sb offset) + (write! sb "bindings=[\n") + (let [offset (inc offset)] + (doseq [{:keys [value]} bindings] + (offset-spaces sb offset) + (to-rpython sb offset value) + (write! sb ",\n")) + (offset-spaces sb offset) + (write! sb "],\n") + + (offset-spaces sb offset) + + (write! sb "body=") + (to-rpython sb offset body) + (write! sb ",\n") + + (offset-spaces sb offset) + (write! sb "meta=") + (write! sb (meta-str sb ast)) + + + (write! sb ")"))) + + (defn writer-context [] {:meta-lines (atom (string-builder)) @@ -624,20 +728,3 @@ str (finish-context (to-rpython (writer-context) 0 (collect-closed-overs (clean-do (analyze form)))))] (print str) (io/spit "/tmp/pxi.py" str)) - -#_'(do - (defprotocol ISeq - (-first [this]) - (-next [this])) - (defprotocol IMeta - (-meta [this])) - (deftype Cons [head tail meta] - ISeq - (-first [this] - head) - (-next [this] - tail) - IMeta - (-meta [this] - meta)) - ) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 0d353971..13e3ed16 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -201,8 +201,40 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_args[len(self._c_acc)] +class Let(AST): + _immutable_fields_ = ["_c_names", "_c_bindings", "_c_body"] + def __init__(self, names, bindings, body, meta): + AST.__init__(self, meta) + self._c_names = names + self._c_bindings = bindings + self._c_body = body + def interpret(self, _, locals, stack): + stack = stack_cons(stack, LetK(self, 0, locals)) + stack = stack_cons(stack, InterpretK(self._c_bindings[0], locals)) + return nil, stack +class LetK(Continuation): + def __init__(self, ast, idx, locals): + self._c_idx = idx + self._c_ast = ast + self._c_locals = locals + + def call_continuation(self, val, stack): + assert isinstance(self._c_ast, Let) + new_locals = Locals(self._c_ast._c_names[self._c_idx], val, self._c_locals) + + if self._c_idx + 1 < len(self._c_ast._c_names): + stack = stack_cons(stack, LetK(self._c_ast, self._c_idx + 1, new_locals)) + stack = stack_cons(stack, InterpretK(self._c_ast._c_bindings[self._c_idx + 1], new_locals)) + else: + stack = stack_cons(stack, InterpretK(self._c_ast._c_body, new_locals)) + + return nil, stack + + + def get_ast(self): + return self._c_ast class If(AST): _immutable_fields_ = ["_c_test", "_c_then", "_c_else"] diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index 90f8b5f0..ca7bcc8e 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -5,7 +5,7 @@ def init(): - import pixie.vm.code as code + import pixie.vm2.code as code from pixie.vm2.object import affirm, _type_registry from rpython.rlib.rarithmetic import r_uint from rpython.rlib.rbigint import rbigint @@ -14,7 +14,6 @@ def init(): from pixie.vm2.object import Object - _type_registry.set_registry(code._ns_registry) def unwrap(fn): if isinstance(fn, code.Var) and fn.is_defined() and hasattr(fn.deref(), "_returns"): @@ -105,28 +104,6 @@ def int_val(x): globals()["int_val"] = int_val - from pixie.vm.code import _ns_registry, BaseCode, munge - - for name, var in _ns_registry._registry[u"pixie.stdlib"]._registry.iteritems(): - name = munge(name) - if var.is_defined() and isinstance(var.deref(), BaseCode): - globals()[name] = unwrap(var) - else: - globals()[name] = var - - import pixie.vm.bootstrap - - def reinit(): - for name, var in _ns_registry._registry[u"pixie.stdlib"]._registry.iteritems(): - name = munge(name) - if name in globals(): - continue - - if var.is_defined() and isinstance(var.deref(), BaseCode): - globals()[name] = unwrap(var) - else: - globals()[name] = var - #f = open("pixie/stdlib.pxi") #data = f.read() #f.close() @@ -160,6 +137,8 @@ def reinit(): globals()["is_true"] = lambda x: False if x is false or x is nil or x is None else True + _type_registry.set_registry(code._ns_registry) + numbers.init() code.init() From 82025331211b998231c7d33b914d2fcc031fab1c Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Fri, 15 May 2015 07:04:49 -0600 Subject: [PATCH 08/46] latest work --- pixie/bootstrap.pxi | 273 ++++++++++++++++++++++++++++++++++++++- pixie/compiler.pxi | 55 ++++---- pixie/vm2/array.py | 30 +++-- pixie/vm2/code.py | 25 +--- pixie/vm2/interpreter.py | 30 ++++- pixie/vm2/numbers.py | 6 + pixie/vm2/object.py | 58 +++++++-- pixie/vm2/rt.py | 17 +++ 8 files changed, 423 insertions(+), 71 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index dd2e10dd..e32a58d8 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -26,8 +26,8 @@ (defprotocol IObject (-hash [this]) (-eq [this other]) - (-str [this]) - (-repr [this])) + (-str [this sbf]) + (-repr [this sbf])) (defprotocol IReduce (-reduce [this f init])) @@ -77,6 +77,9 @@ (defprotocol ITransientCollection (-conj! [this x])) +(defprotocol IToTransient + (-transient [this x])) + (defprotocol ITransientStack (-push! [this x]) (-pop! [this])) @@ -88,6 +91,14 @@ (-get-field [this name]) (-invoke-method [this name args])) + +(extend -get-field Object -internal-get-field) +(extend -str Object (fn [x sb] + (sb (-internal-tostr x)))) +(extend -repr Object (fn [x sb] + (sb (-internal-to-repr x)))) + + ;; Math wrappers (extend -eq Number -num-eq) @@ -120,6 +131,11 @@ ([x y & more] (-apply < (< x y) more))) +(defn > + ([x y] (-gt x y)) + ([x y & more] + (-apply > (> x y) more))) + (defn = {:doc "Returns true if all the arguments are equivalent. Otherwise, returns false. Uses -eq to perform equality checks." @@ -133,6 +149,17 @@ (apply = y rest) false))) +(defn conj + ([] []) + ([coll] coll) + ([coll itm] (-conj coll itm)) + ([coll item & more] + (-apply conj (conj x y) more))) + + +(defn count + ([coll] (-count coll))) + (deftype Cons [first next meta] ISeq @@ -148,7 +175,209 @@ (defn cons [head tail] (->Cons head (seq tail) nil)) +;; String Builder + +(defn string-builder + ([] (-string-builder)) + ([sb] (-str sb)) + ([sb x] + (if (instance? String x) + (-add-to-string-builder x) + (-add-to-string-bulder (-str x))))) + +(defn str [& args] + (transduce + (map str) + string-builder + args)) + +(defn println [& args] + (-blocking-println (-apply str args))) + +;; + +;; Type Helpers + + +(defn instance? + ^{:doc "Checks if x is an instance of t. + When t is seqable, checks if x is an instance of + any of the types contained therein." + :signatures [[t x]]} + [t x] + (if (-satisfies? ISeqable t) + (let [ts (seq t)] + (if (not ts) false + (if (-instance? (first ts) x) + true + (instance? (rest ts) x)))) + (-instance? t x))) + +;; End Type Helpers + +;; Reduced + +(deftype Reduced [x] + IDeref + (-deref [this] x)) + +(defn reduced [x] + (->Reduced x)) + +(defn reduced? [x] + (instance? Reduced x)) + +;; End Reduced + +;; Satisfies + +(defn satisfies? + ^{:doc "Checks if x satisfies the protocol p. + + When p is seqable, checks if x satisfies all of + the protocols contained therein." + :signatures [[t x]]} + [p x] + (if (-satisfies? ISeqable p) + (let [ps (seq p)] + (if (not ps) true + (if (not (-satisfies? (first ps) x)) + false + (satisfies? (rest ps) x)))) + (-satisfies? p x))) + +;; End Satisfies + +;; Basic Transducer Support + +(defn transduce + ([f coll] + (let [result (-reduce coll f (f))] + (f result))) + ([xform rf coll] + (let [f (xform rf) + result (-reduce coll f (f))] + (f result))) + ([xform rf init coll] + (let [f (xform rf) + result (-reduce coll f init)] + (f result)))) + +(defn reduce + ([rf col] + (reduce rf (rf) col)) + ([rf init col] + (-reduce col rf init))) + +(defn into + ^{:doc "Add the elements of `from` to the collection `to`." + :signatures [[to from]] + :added "0.1"} + ([to from] + (if (satisfies? IToTransient to) + (persistent! (reduce conj! (transient to) from)) + (reduce conj to from))) + ([to xform from] + (if (satisfies? IToTransient to) + (transduce xform conj! (transient to) from) + (transduce xform conj to from)))) + +(defn map + ^{:doc "map - creates a transducer that applies f to every input element" + :signatures [[f] [f coll]] + :added "0.1"} + ([f] + (fn [xf] + (fn + ([] (xf)) + ([result] (xf result)) + ([result item] (xf result (f item)))))) + ([f coll] + (lazy-seq* + (fn [] + (let [s (seq coll)] + (if s + (cons (f (first s)) + (map f (rest s))) + nil))))) + ([f & colls] + (let [step (fn step [cs] + (lazy-seq* + (fn [] + (let [ss (map seq cs)] + (if (every? identity ss) + (cons (map first ss) (step (map rest ss))) + nil)))))] + (map (fn [args] (apply f args)) (step colls))))) + +;; End Basic Transudcer Support + +;; Range + +(deftype Range [start stop step] + IReduce + (-reduce [self f init] + (loop [i start + acc init] + (println i) + (if (or (and (> step 0) (< i stop)) + (and (< step 0) (> i stop)) + (and (= step 0))) + (let [acc (f acc i)] + (if (reduced? acc) + @acc + (recur (+ i step) acc))) + acc))) + ICounted + (-count [self] + (if (or (and (< start stop) (< step 0)) + (and (> start stop) (> step 0)) + (= step 0)) + 0 + (abs (quot (- start stop) step)))) + IIndexed + (-nth [self idx] + (when (or (= start stop 0) (neg? idx)) + (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"])) + (let [cmp (if (< start stop) < >) + val (+ start (* idx step))] + (if (cmp val stop) + val + (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"])))) + (-nth-not-found [self idx not-found] + (let [cmp (if (< start stop) < >) + val (+ start (* idx step))] + (if (cmp val stop) + val + not-found))) + ISeqable + (-seq [self] + (when (or (and (> step 0) (< start stop)) + (and (< step 0) (> start stop))) + (cons start (lazy-seq* #(range (+ start step) stop step))))) + IObject + (-str [this sbf] + (-str (seq this) sbf)) + (-repr [this sbf] + (-repr (seq this) sbf)) + (-eq [this sb])) + +(def MAX-NUMBER 0xFFFFFFFF) ;; 32 bits ought to be enough for anyone ;-) + +(defn range + {:doc "Returns a range of numbers." + :examples [["(seq (range 3))" nil (0 1 2)] + ["(seq (range 3 5))" nil (3 4)] + ["(seq (range 0 10 2))" nil (0 2 4 6 8)] + ["(seq (range 5 -1 -1))" nil (5 4 3 2 1 0)]] + :signatures [[] [stop] [start stop] [start stop step]] + :added "0.1"} + ([] (->Range 0 MAX-NUMBER 1)) + ([stop] (->Range 0 stop 1)) + ([start stop] (->Range start stop 1)) + ([start stop step] (->Range start stop step))) +;; End Range ;; PersistentVector @@ -243,8 +472,42 @@ (new-path edit (- level 5) node)))) -(def EMPTY (->PersistentVector nil 0 5 EMPTY-NODE (array 0))) +(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil)) + +(defn vector-from-array [arr] + (if (< (count arr) 32) + (->PersistentVector (count arr) 5 EMPTY-NODE arr nil) + (into [] arr))) + +;; Extend Array + +(extend-type Array + IPersistentCollection + (-conj ([arr itm] + (conj (vector-from-array arr) itm))) + ICounted + (-count ([arr] + (.-count arr))) + + IReduce + (-reduce [this f init] + (loop [idx 0 + acc init] + (if (reduced? acc) + @acc + (if (< idx (count this)) + (recur (inc idx) + (f acc (aget this idx))) + acc))))) + + +;;; + +(into [] (range 1000)) -(let [x 4] - (+ x 1)) +#_(let [v EMPTY] + (loop [acc EMPTY + i 0] + (if (< i 1000) + (recur (conj v i) (inc i))))) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index bd8638ef..6f0bb380 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -50,18 +50,13 @@ [proto (conj tbs body) pbs])))) [nil [] []] body) - type-bodies (second bodies) - proto-bodies (third bodies) - all-fields (reduce (fn [r tb] (conj r (keyword (name (first tb))))) fields type-bodies) + proto-bodies (second bodies) + all-fields fields type-decl `(def ~nm (create-type ~(keyword (name nm)) ~all-fields)) inst (gensym) ctor `(defn ~ctor-name ~field-syms (new ~nm - ~@field-syms - ~@(transduce (map (fn [type-body] - (mk-body type-body))) - conj - type-bodies))) + ~@field-syms)) proto-bodies (transduce (map (fn [body] (cond @@ -153,6 +148,7 @@ (let [[args variadic?] (let [not& (vec (filter (complement (partial = '&)) args))] [not& (= '& (last (butlast args)))]) arity (count args) + arity-idx (if variadic? -1 arity) new-env (update-in *env* [:locals] (fn [locals] (reduce (fn [locals [k v]] @@ -175,8 +171,8 @@ :env *env*}))) new-env (range (count args)))] - (assert (not (acc arity)) (str "Duplicate arity for " (cons args body))) - (assoc acc arity {:op :fn-body + (assert (not (acc arity-idx)) (str "Duplicate arity for " (cons args body))) + (assoc acc arity-idx {:op :fn-body :env *env* :arity arity :args args @@ -221,6 +217,17 @@ :body (binding [*env* new-env] (analyze-form `(do ~@body)))})) +(defmethod analyze-seq 'loop* + [[_ bindings & body]] + (let [parted (partition 2 bindings)] + (analyze-form `((fn __loop__fn__ ~(mapv first parted) + ~@body) + ~@(mapv second parted))))) + +(defmethod analyze-seq 'recur + [[_ & args]] + (analyze-form `(__loop__fn__ ~@args))) + (defmethod analyze-seq 'def [[_ nm val :as form]] (swap! (:vars *env*) update-in [(:ns *env*) nm] (fn [x] @@ -256,6 +263,13 @@ :env *env* :form nil}) +(defn keep-meta [new old] + (if-let [md (meta old)] + (if (satisfies? IMeta new) + (with-meta new md) + new) + new)) + (defmethod analyze-seq :default [[sym & args :as form]] (let [resolved (and (symbol? sym) @@ -264,27 +278,19 @@ (and (symbol? sym) (string/starts-with? (name sym) ".-")) (let [sym-kw (keyword (string/substring (name sym) 2))] - {:op :invoke - :tail-call (:tail? *env*) - :children '[:fn :args] - :form form - :env *env* - :fn {:op :var - :env *env* - :ns (:ns *env*) - :name 'pixie.stdlib/-get-field - :form 'pixie.stdlib/-get-field} - :args (binding [*env* (assoc *env* :tail? false)] - (mapv analyze-form (cons sym-kw args)))}) + (analyze-form (keep-meta `(-get-field ~@args ~sym-kw) + form))) (and resolved (contains? macro-overrides resolved)) - (analyze-form (apply (macro-overrides resolved) args)) + (analyze-form (keep-meta (apply (macro-overrides resolved) args) + form)) (and resolved (macro? @resolved)) - (analyze-form (apply @resolved args)) + (analyze-form (keep-meta (apply @resolved args) + form)) :else {:op :invoke @@ -471,7 +477,6 @@ (defmethod to-rpython :if [sb offset {:keys [test then else] :as ast}] - #_(offset-spaces sb offset) (write! sb "i.If(\n") (let [offset (inc offset)] (doseq [[nm form] [[:test test] diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py index ccf3bd96..c1498152 100644 --- a/pixie/vm2/array.py +++ b/pixie/vm2/array.py @@ -8,9 +8,13 @@ import rpython.rlib.jit as jit from rpython.rtyper.lltypesystem import lltype from rpython.rlib.rarithmetic import intmask - +from pixie.vm2.keyword import keyword +import pixie.vm2.rt as rt UNROLL_IF_SMALLER_THAN = 8 +KW_count = keyword(u"count") + + class Array(object.Object): _type = object.Type(u"pixie.stdlib.Array") _immutable_fields_ = ["_list"] @@ -36,16 +40,20 @@ def reduce_large(self, f, init): init = f.invoke([init, self._list[x]]) return init + def get_field(self, k): + if k is KW_count: + return rt.wrap(len(self._list)) + return nil + @as_var("array") def array__args(lst): return Array(lst) -# -# -# @extend(proto._count, Array) -# def _count(self): -# assert isinstance(self, Array) -# return rt.wrap(len(self._list)) + +#@extend(proto._count, Array) +#def _count(self): +# assert isinstance(self, Array) +# return rt.wrap(len(self._list)) # # @extend(proto._nth, Array) # def _nth(self, idx): @@ -131,10 +139,10 @@ def array__args(lst): # assert isinstance(lst, list) # return Array(lst) # -# @as_var("aget") -# def aget(self, idx): -# assert isinstance(self, Array) -# return self._list[idx.int_val()] +@as_var("aget") +def aget(self, idx): + assert isinstance(self, Array) + return self._list[idx.int_val()] # # @as_var("aset") # def aset(self, idx, val): diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index 35038c1b..fcc554d3 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -250,11 +250,8 @@ def invoke(self, args): u":pixie.stdlib/InvalidArityException") def invoke_with(self, args, this_fn): - try: - return interpret(self, args, self_obj=this_fn) - except object.WrappedException as ex: - ex._ex._trace.append(object.PixieCodeInfo(self._name)) - raise + return interpret(self, args, self_obj=this_fn) + @elidable_promote() def get_arity(self): @@ -345,13 +342,7 @@ def invoke(self, args): return self.invoke_with(args, self) def invoke_with(self, args, self_fn): - try: - return interpret(self, args, self_obj=self_fn) - except object.WrappedException as ex: - code = self._code - assert isinstance(code, Code) - ex._ex._trace.append(object.PixieCodeInfo(code._name)) - raise + return interpret(self, args, self_obj=self_fn) def get_closed_over(self, idx): return self._closed_overs[idx] @@ -728,15 +719,11 @@ def get_protocol_fn(self, tp, rev): return promote(fn) - def invoke(self, args): + def invoke_k(self, args, stack): affirm(len(args) >= 1, u"Wrong number of args") a = args[0].type() fn = self.get_protocol_fn(a, self._rev) - try: - return fn.invoke(args) - except object.WrappedException as ex: - ex._ex._trace.append(object.PolymorphicCodeInfo(self._name, args[0].type())) - raise + return fn.invoke_k(args, stack) class DoublePolymorphicFn(BaseCode): @@ -919,7 +906,7 @@ def wrapped_fn(self, args): try: return fn(args[0], args[1], args[2], args[3]) except object.WrappedException as ex: - ex._ex._trace.append(object.NativeCodeInfo(fn_name)) + #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) raise return as_native_fn(wrapped_fn) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 13e3ed16..6ddbe5c5 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -16,6 +16,11 @@ def get_short_location(self): return self._c_meta.get_short_location() return "" + def get_long_location(self): + if self._c_meta != nil: + return self._c_meta.get_long_location() + return "" + class Meta(Object): _type = Type(u"pixie.stdlib.Meta") _immutable_fields_ = ["_c_column_number", "_c_line_tuple"] @@ -26,7 +31,26 @@ def __init__(self, line_tuple, column_number): def get_short_location(self): (line, file, line_number) = self._c_line_tuple - return str(file) + " @ " + str(line[:self._c_column_number]) + "^" + str(line[self._c_column_number:]) + cl = self._c_column_number - 1 + assert cl >= 0 + return str(file) + " @ " + str(line[:cl]) + "^" + str(line[cl:]) + + def get_long_location(self): + (line, file, line_number) = self._c_line_tuple + ld = [] + ld.append(str(line)) + ld.append(" in ") + ld.append(str(file)) + ld.append(" at ") + ld.append(str(line_number)+":"+str(self._c_column_number)) + ld.append("\n") + for x in range(self._c_column_number - 1): + ld.append(" ") + ld.append("^\n") + + return "".join(ld) + + class PrevASTNil(AST): def __init__(self): @@ -116,7 +140,8 @@ def invoke_k(self, args, stack): @jit.unroll_safe def invoke_k_with(self, args, stack, self_fn): # TODO: Check arg count - locals = Locals(jit.promote(self._c_name), self_fn, self._c_locals) + locals = jit.promote(self._c_locals) + locals = Locals(jit.promote(self._c_name), self_fn, locals) arg_names = jit.promote(self._c_arg_names) for idx in range(len(arg_names)): locals = Locals(arg_names[idx], args[idx], locals) @@ -215,6 +240,7 @@ def interpret(self, _, locals, stack): return nil, stack class LetK(Continuation): + _immutable_ = True def __init__(self, ast, idx, locals): self._c_idx = idx self._c_ast = ast diff --git a/pixie/vm2/numbers.py b/pixie/vm2/numbers.py index 85582751..dee182f7 100644 --- a/pixie/vm2/numbers.py +++ b/pixie/vm2/numbers.py @@ -35,6 +35,12 @@ def promote(self): def type(self): return Integer._type + def to_str(self): + return unicode(str(self._int_val)) + + def to_repr(self): + return unicode(str(self._int_val)) + zero_int = Integer(0) one_int = Integer(1) diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index 65f58948..6b52da29 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -30,6 +30,21 @@ def hash(self): def promote(self): return self + def get_field(self, k): + runtime_error(u"Unsupported operation get-field") + + def to_str(self): + tp = self.type() + assert isinstance(tp, Type) + return u"" + + def to_repr(self): + tp = self.type() + assert isinstance(tp, Type) + return u"" + + + class TypeRegistry(object): def __init__(self): self._types = {} @@ -97,9 +112,9 @@ def subclasses(self): Type._type = Type(u"pixie.stdlib.Type") @jit.elidable_promote() -def istypeinstance(obj, t): - obj_type = obj.type() - assert isinstance(obj_type, Type) +def istypeinstance(obj_type, t): + if not isinstance(obj_type, Type): + return False if obj_type is t: return True elif obj_type._parent is not None: @@ -147,7 +162,12 @@ def run_stack(val, cont, stack=None): prev_ast = PrevASTNil() while True: jitdriver.jit_merge_point(ast=ast, prev_ast=prev_ast, stack=stack, val=val, cont=cont) - val, stack = cont.call_continuation(val, stack) + try: + val, stack = cont.call_continuation(val, stack) + except BaseException as ex: + print_stacktrace(cont, stack) + #print ex + break if stack is None: return val prev_ast = ast @@ -161,17 +181,37 @@ def run_stack(val, cont, stack=None): return val +def stacktrace_for_cont(cont): + ast = cont.get_ast() + if ast: + return ast.get_long_location() + +def print_stacktrace(cont, stack): + st = [] + st.append(stacktrace_for_cont(cont)) + while stack: + st.append(stacktrace_for_cont(stack._cont)) + stack = stack._parent + st.reverse() + for line in st: + print line - +class RuntimeException(Object): + _type = Type(u"pixie.stdlib.RuntimeException") + def __init__(self, msg, kw): + self._msg = msg + self._kw = kw ## TODO: fix def affirm(f, msg): if not f: print msg - raise NotImplementedError() + raise WrappedException(RuntimeException(msg, u"pixie.stdlib.AssertionException")) + +class WrappedException(BaseException): + def __init__(self, ex): + self._ex = ex def runtime_error(msg, kw=None): - raise NotImplementedError() + raise WrappedException(RuntimeException(msg, kw)) -class WrappedException(BaseException): - pass \ No newline at end of file diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index ca7bcc8e..7a7d6f49 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -143,6 +143,23 @@ def int_val(x): code.init() +def unwrap_string(x): + from pixie.vm2.string import String + from pixie.vm2.object import affirm + + affirm(isinstance(x, String), u"Expected String") + assert isinstance(x, String) + + return x._str + +def unwrap_keyword(x): + from pixie.vm2.keyword import Keyword + from pixie.vm2.object import affirm + + affirm(isinstance(x, Keyword), u"Expected Keyword") + assert isinstance(x, Keyword) + + return x._str From 6d4abb4a24807d75b5aa40308e4cf8197ea8f2ff Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Fri, 15 May 2015 16:44:12 -0600 Subject: [PATCH 09/46] latest work, adding bootstrap, debugging vectors --- bootstrap.py | 3731 ++++++++++++++++++++++++++++++++++++++ pixie/bootstrap.pxi | 22 +- pixie/compiler.pxi | 2 +- pixie/vm2/interpreter.py | 7 +- pixie/vm2/object.py | 6 +- target2.py | 2 +- 6 files changed, 3764 insertions(+), 6 deletions(-) create mode 100755 bootstrap.py diff --git a/bootstrap.py b/bootstrap.py new file mode 100755 index 00000000..ee122a38 --- /dev/null +++ b/bootstrap.py @@ -0,0 +1,3731 @@ +mid0 = (u"""(defprotocol ISeq""", "", 4) +mid1 = (u"""(defprotocol ISeqable""", "", 8) +mid2 = (u"""(defprotocol ICounted""", "", 11) +mid3 = (u"""(defprotocol IIndexed""", "", 14) +mid4 = (u"""(defprotocol IPersistentCollection""", "", 19) +mid5 = (u"""(defprotocol IEmpty""", "", 23) +mid6 = (u"""(defprotocol IObject""", "", 26) +mid7 = (u"""(defprotocol IReduce""", "", 32) +mid8 = (u"""(defprotocol IDeref""", "", 35) +mid9 = (u"""(defprotocol IReset""", "", 38) +mid10 = (u"""(defprotocol INamed""", "", 41) +mid11 = (u"""(defprotocol IAssociative""", "", 45) +mid12 = (u"""(defprotocol ILookup""", "", 50) +mid13 = (u"""(defprotocol IMapEntry""", "", 53) +mid14 = (u"""(defprotocol IStack""", "", 57) +mid15 = (u"""(defprotocol IPop""", "", 60) +mid16 = (u"""(defprotocol IFn""", "", 63) +mid17 = (u"""(defprotocol IDoc""", "", 66) +mid18 = (u"""(defprotocol IMeta""", "", 73) +mid19 = (u"""(defprotocol ITransientCollection""", "", 77) +mid20 = (u"""(defprotocol IToTransient""", "", 80) +mid21 = (u"""(defprotocol ITransientStack""", "", 83) +mid22 = (u"""(defprotocol IDisposable""", "", 87) +mid23 = (u"""(defprotocol IMessageObject""", "", 90) +mid24 = (u"""(extend -get-field Object -internal-get-field)""", "", 96) +mid25 = (u"""(extend -str Object (fn [x sb]""", "", 97) +mid26 = (u""" (sb (-internal-to-str x))))""", "", 98) +mid27 = (u"""(extend -repr Object (fn [x sb]""", "", 99) +mid28 = (u""" (sb (-internal-to-repr x))))""", "", 100) +mid29 = (u""" (-str [this sb]""", "", 105) +mid30 = (u"""(extend-type String""", "", 103) +mid31 = (u""" (sb this)))""", "", 106) +mid32 = (u"""(extend -eq Number -num-eq)""", "", 110) +mid33 = (u""" ([x] x)""", "", 117) +mid34 = (u""" ([x y] (-add x y))""", "", 118) +mid35 = (u""" (-apply + (+ x y) more)))""", "", 120) +mid36 = (u""" ([x] x)""", "", 124) +mid37 = (u""" ([x y] (-sub x y))""", "", 125) +mid38 = (u""" (-apply - (- x y) more))) """, "", 127) +mid39 = (u""" ([x] (+ x 1)))""", "", 130) +mid40 = (u""" ([x] (- x 1)))""", "", 133) +mid41 = (u""" ([x y] (-lt x y))""", "", 136) +mid42 = (u""" (-apply < (< x y) more)))""", "", 138) +mid43 = (u""" ([x y] (-gt x y))""", "", 141) +mid44 = (u""" (-apply > (> x y) more)))""", "", 143) +mid45 = (u""" ([x y] (if (identical? x y)""", "", 151) +mid46 = (u""" (-eq x y)))""", "", 153) +mid47 = (u""" ([x y & rest] (if (eq x y)""", "", 154) +mid48 = (u""" (apply = y rest)""", "", 155) +mid49 = (u""" ([coll] coll)""", "", 160) +mid50 = (u""" ([coll itm] (-conj coll itm))""", "", 161) +mid51 = (u""" (-apply conj (conj x y) more)))""", "", 163) +mid52 = (u""" ([coll] (-count coll)))""", "", 167) +mid53 = (u"""(deftype Cons [first next meta]""", "", 170) +mid54 = (u""" (-first [this] first)""", "", 172) +mid55 = (u""" (-next [this] next)""", "", 173) +mid56 = (u""" (-seq [this] this)""", "", 175) +mid57 = (u""" (-meta [this] meta)""", "", 177) +mid58 = (u""" (-with-meta [this new-meta]""", "", 178) +mid59 = (u""" (->Cons first next new-meta)))""", "", 179) +mid60 = (u""" (->Cons head (seq tail) nil))""", "", 182) +mid61 = (u""" ([] (-string-builder))""", "", 187) +mid62 = (u""" ([sb] (-str sb))""", "", 188) +mid63 = (u""" (if (instance? String x)""", "", 190) +mid64 = (u""" (-add-to-string-builder x)""", "", 191) +mid65 = (u""" (-add-to-string-bulder (-str x)))))""", "", 192) +mid66 = (u""" (transduce""", "", 195) +mid67 = (u""" (map str)""", "", 196) +mid68 = (u""" string-builder""", "", 197) +mid69 = (u""" args))""", "", 198) +mid70 = (u""" (let [sb (-string-builder)""", "", 201) +mid71 = (u""" (-add-to-string-builder sb x))]""", "", 203) +mid72 = (u""" sb sb]""", "", 205) +mid73 = (u""" (loop [idx 0""", "", 204) +mid74 = (u""" (if (< idx (count args))""", "", 206) +mid75 = (u""" (recur (inc idx)""", "", 207) +mid76 = (u""" (do (-str (aget args idx) add-fn)""", "", 208) +mid77 = (u""" (add-fn " ")""", "", 209) +mid78 = (u""" sb))""", "", 210) +mid79 = (u""" (-blocking-println (-finish-string-builder sb))))""", "", 211) +mid80 = (u""" (if (-satisfies? ISeqable t)""", "", 225) +mid81 = (u""" (let [ts (seq t)]""", "", 226) +mid82 = (u""" (if (not ts) false""", "", 227) +mid83 = (u""" (if (-instance? (first ts) x)""", "", 228) +mid84 = (u""" (instance? (rest ts) x))))""", "", 230) +mid85 = (u""" (-instance? t x)))""", "", 231) +mid86 = (u"""(deftype Reduced [x]""", "", 237) +mid87 = (u""" (-deref [this] x))""", "", 239) +mid88 = (u""" (->Reduced x))""", "", 242) +mid89 = (u""" (instance? Reduced x))""", "", 245) +mid90 = (u""" (if (-satisfies? ISeqable p)""", "", 258) +mid91 = (u""" (let [ps (seq p)]""", "", 259) +mid92 = (u""" (if (not ps) true""", "", 260) +mid93 = (u""" (if (not (-satisfies? (first ps) x))""", "", 261) +mid94 = (u""" (satisfies? (rest ps) x))))""", "", 263) +mid95 = (u""" (-satisfies? p x)))""", "", 264) +mid96 = (u""" (let [f (xform rf)""", "", 275) +mid97 = (u""" result (-reduce coll f (f))]""", "", 276) +mid98 = (u""" (f result)))""", "", 277) +mid99 = (u""" (let [result (-reduce coll f (f))]""", "", 272) +mid100 = (u""" (f result)))""", "", 273) +mid101 = (u""" (let [f (xform rf)""", "", 279) +mid102 = (u""" result (-reduce coll f init)]""", "", 280) +mid103 = (u""" (f result))))""", "", 281) +mid104 = (u""" (-reduce col rf init)))""", "", 287) +mid105 = (u""" (reduce rf (rf) col))""", "", 285) +mid106 = (u""" (if (satisfies? IToTransient to)""", "", 298) +mid107 = (u""" (transduce xform conj! (transient to) from)""", "", 299) +mid108 = (u""" (transduce xform conj to from))))""", "", 300) +mid109 = (u""" (if (satisfies? IToTransient to)""", "", 294) +mid110 = (u""" (persistent! (reduce conj! (transient to) from))""", "", 295) +mid111 = (u""" (reduce conj to from)))""", "", 296) +mid112 = (u""" ([] (xf))""", "", 309) +mid113 = (u""" ([result] (xf result))""", "", 310) +mid114 = (u""" ([result item] (xf result (f item))))))""", "", 311) +mid115 = (u""" (lazy-seq*""", "", 313) +mid116 = (u""" (let [s (seq coll)]""", "", 315) +mid117 = (u""" (if s""", "", 316) +mid118 = (u""" (cons (f (first s))""", "", 317) +mid119 = (u""" (map f (rest s)))""", "", 318) +mid120 = (u""" (lazy-seq*""", "", 322) +mid121 = (u""" (let [ss (map seq cs)]""", "", 324) +mid122 = (u""" (if (every? identity ss)""", "", 325) +mid123 = (u""" (cons (map first ss) (step (map rest ss)))""", "", 326) +mid124 = (u""" (map (fn [args] (apply f args)) (step colls)))))""", "", 328) +mid125 = (u""" (let [step (fn step [cs]""", "", 321) +mid126 = (u"""(deftype Range [start stop step]""", "", 334) +mid127 = (u""" (-reduce [self f init]""", "", 336) +mid128 = (u""" acc init]""", "", 338) +mid129 = (u""" (loop [i start""", "", 337) +mid130 = (u""" (println i)""", "", 339) +mid131 = (u""" (if (or (and (> step 0) (< i stop))""", "", 340) +mid132 = (u""" (and (< step 0) (> i stop))""", "", 341) +mid133 = (u""" (and (= step 0)))""", "", 342) +mid134 = (u""" (let [acc (f acc i)]""", "", 343) +mid135 = (u""" (if (reduced? acc)""", "", 344) +mid136 = (u""" @acc""", "", 345) +mid137 = (u""" (recur (+ i step) acc)))""", "", 346) +mid138 = (u""" acc)))""", "", 347) +mid139 = (u""" (-count [self]""", "", 349) +mid140 = (u""" (if (or (and (< start stop) (< step 0))""", "", 350) +mid141 = (u""" (and (> start stop) (> step 0))""", "", 351) +mid142 = (u""" (= step 0))""", "", 352) +mid143 = (u""" (abs (quot (- start stop) step))))""", "", 354) +mid144 = (u""" (-nth [self idx]""", "", 356) +mid145 = (u""" (when (or (= start stop 0) (neg? idx))""", "", 357) +mid146 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))""", "", 358) +mid147 = (u""" (-nth-not-found [self idx not-found]""", "", 364) +mid148 = (u""" (let [cmp (if (< start stop) < >)""", "", 365) +mid149 = (u""" val (+ start (* idx step))]""", "", 366) +mid150 = (u""" (if (cmp val stop)""", "", 367) +mid151 = (u""" val""", "", 368) +mid152 = (u""" not-found)))""", "", 369) +mid153 = (u""" (-seq [self]""", "", 371) +mid154 = (u""" (when (or (and (> step 0) (< start stop))""", "", 372) +mid155 = (u""" (and (< step 0) (> start stop)))""", "", 373) +mid156 = (u""" (cons start (lazy-seq* #(range (+ start step) stop step)))))""", "", 374) +mid157 = (u""" (-str [this sbf]""", "", 376) +mid158 = (u""" (-str (seq this) sbf))""", "", 377) +mid159 = (u""" (-repr [this sbf]""", "", 378) +mid160 = (u""" (-repr (seq this) sbf))""", "", 379) +mid161 = (u""" (-eq [this sb]))""", "", 380) +mid162 = (u""" ([] (->Range 0 MAX-NUMBER 1))""", "", 392) +mid163 = (u""" ([stop] (->Range 0 stop 1))""", "", 393) +mid164 = (u""" ([start stop step] (->Range start stop step)))""", "", 395) +mid165 = (u""" ([start stop] (->Range start stop 1))""", "", 394) +mid166 = (u"""(deftype Node [edit array]""", "", 401) +mid167 = (u""" (-get-field [this name]""", "", 403) +mid168 = (u""" (get-field this name)))""", "", 404) +mid169 = (u""" (new-node edit (array 32)))""", "", 408) +mid170 = (u""" (->Node edit array)))""", "", 410) +mid171 = (u"""(def EMPTY-NODE (new-node nil))""", "", 412) +mid172 = (u""" (let [cnt (.-cnt this)]""", "", 417) +mid173 = (u""" (if (< cnt 32)""", "", 418) +mid174 = (u""" (bit-shift-left (bit-shift-right (dec cnt) 5) 5))))""", "", 420) +mid175 = (u""" (if (and (<= 0 i) (< i cnt))""", "", 423) +mid176 = (u""" (if (>= i (tailoff this))""", "", 424) +mid177 = (u""" tail""", "", 425) +mid178 = (u""" (if (> level 0)""", "", 427) +mid179 = (u""" (look-deeper (aget (:array node)""", "", 428) +mid180 = (u""" (bit-and (bit-shift-right i level) 0x01f))""", "", 429) +mid181 = (u""" (- level 5))""", "", 430) +mid182 = (u""" (:array node)))""", "", 431) +mid183 = (u""" root""", "", 432) +mid184 = (u""" shift)))))""", "", 433) +mid185 = (u""" (.-array ((fn look-deeper [node level]""", "", 426) +mid186 = (u"""(deftype PersistentVector [cnt shift root tail meta]""", "", 435) +mid187 = (u""" (-get-field [this name]""", "", 437) +mid188 = (u""" (get-field this name))""", "", 438) +mid189 = (u""" (-conj [this val]""", "", 441) +mid190 = (u""" (assert (< cnt 0xFFFFFFFF) "Vector too large")""", "", 442) +mid191 = (u""" (-count [this] cnt))""", "", 465) +mid192 = (u""" (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f)""", "", 469) +mid193 = (u""" ret-array (aclone (.-array parent))""", "", 470) +mid194 = (u""" node-to-insert (if (= level 5)""", "", 471) +mid195 = (u""" tail-node""", "", 472) +mid196 = (u""" (let [child (aget (.-array parent) subidx)]""", "", 473) +mid197 = (u""" (if (= child nil)""", "", 474) +mid198 = (u""" (new-path (.-edit (.-root this))""", "", 475) +mid199 = (u""" (- level 5)""", "", 476) +mid200 = (u""" tail-node)""", "", 477) +mid201 = (u""" (push-tail this""", "", 478) +mid202 = (u""" (- level 5)""", "", 479) +mid203 = (u""" child""", "", 480) +mid204 = (u""" tail-node))))]""", "", 481) +mid205 = (u""" (aset ret-array subidx node-to-insert)""", "", 482) +mid206 = (u""" (->Node (.-edit parent) node-to-insert)))""", "", 483) +mid207 = (u""" (if (= level 0)""", "", 486) +mid208 = (u""" node""", "", 487) +mid209 = (u""" (->Node edit""", "", 488) +mid210 = (u""" (new-path edit (- level 5) node))))""", "", 489) +mid211 = (u"""(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil))""", "", 492) +mid212 = (u""" (if (< (count arr) 32)""", "", 495) +mid213 = (u""" (->PersistentVector (count arr) 5 EMPTY-NODE arr nil)""", "", 496) +mid214 = (u""" (into [] arr)))""", "", 497) +mid215 = (u""" (-reduce [this f init]""", "", 510) +mid216 = (u"""(extend-type Array""", "", 501) +mid217 = (u""" acc init]""", "", 512) +mid218 = (u""" (loop [idx 0""", "", 511) +mid219 = (u""" (if (reduced? acc)""", "", 513) +mid220 = (u""" @acc""", "", 514) +mid221 = (u""" (if (< idx (count this))""", "", 515) +mid222 = (u""" (recur (inc idx)""", "", 516) +mid223 = (u""" (f acc (aget this idx)))""", "", 517) +mid224 = (u""" acc)))))""", "", 518) +mid225 = (u""" (-count ([arr]""", "", 506) +mid226 = (u""" (.-count arr)))""", "", 507) +mid227 = (u""" (-conj ([arr itm]""", "", 503) +mid228 = (u""" (conj (vector-from-array arr) itm)))""", "", 504) +mid229 = (u"""(println 42)""", "", 523) +mid230 = (u"""(into [] (range 1000))""", "", 525) +mid231 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) + + +code_ast=i.Do( + args=[ + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/ISeq) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"ISeq")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"ISeq")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-first) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-first")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-first")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid0, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-next) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-next")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-next")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid0, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid0, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/ISeqable) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"ISeqable")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"ISeqable")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-seq) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-seq")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-seq")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid1, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid1, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/ICounted) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"ICounted")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"ICounted")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-count) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-count")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-count")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ICounted"), meta=i.Meta(mid2, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid2, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IIndexed) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IIndexed")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IIndexed")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-nth) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-nth")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-nth")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid3, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-nth-not-found) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-nth-not-found")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-nth-not-found")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid3, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid3, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IPersistentCollection) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IPersistentCollection")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IPersistentCollection")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-conj) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-conj")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-conj")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid4, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-disj) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-disj")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-disj")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid4, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid4, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IEmpty) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IEmpty")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IEmpty")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-empty) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-empty")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-empty")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IEmpty"), meta=i.Meta(mid5, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid5, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IObject) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IObject")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IObject")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-hash) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-hash")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-hash")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-eq) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-eq")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-eq")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-str) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-str")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-str")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-repr) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-repr")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-repr")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid6, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IReduce) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IReduce")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IReduce")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-reduce) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-reduce")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-reduce")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IReduce"), meta=i.Meta(mid7, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid7, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IDeref) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IDeref")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IDeref")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-deref) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-deref")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-deref")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IDeref"), meta=i.Meta(mid8, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid8, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IReset) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IReset")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IReset")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-reset!) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-reset!")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-reset!")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IReset"), meta=i.Meta(mid9, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid9, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/INamed) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"INamed")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"INamed")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-namespace) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-namespace")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-namespace")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid10, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-name) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-name")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-name")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid10, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid10, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IAssociative) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IAssociative")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IAssociative")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-assoc) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-assoc")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-assoc")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid11, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-contains-key) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-contains-key")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-contains-key")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid11, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-dissoc) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-dissoc")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-dissoc")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid11, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid11, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/ILookup) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"ILookup")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"ILookup")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-get) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-get")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-get")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ILookup"), meta=i.Meta(mid12, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid12, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IMapEntry) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IMapEntry")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IMapEntry")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-key) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-key")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-key")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid13, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-val) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-val")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-val")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid13, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid13, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IStack) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IStack")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IStack")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-push) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-push")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-push")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IStack"), meta=i.Meta(mid14, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid14, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IPop) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IPop")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IPop")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-pop) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-pop")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-pop")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IPop"), meta=i.Meta(mid15, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid15, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IFn) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IFn")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IFn")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-invoke) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-invoke")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-invoke")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IFn"), meta=i.Meta(mid16, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid16, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IDoc) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IDoc")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IDoc")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-doc) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-doc")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-doc")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IDoc"), meta=i.Meta(mid17, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid17, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/IVector) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IVector")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IVector")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/ISequential) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"ISequential")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"ISequential")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/IMap) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IMap")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IMap")), + ], + meta=nil)]), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IMeta) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IMeta")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IMeta")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-with-meta) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-with-meta")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-with-meta")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid18, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-meta) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-meta")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-meta")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid18, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid18, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/ITransientCollection) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"ITransientCollection")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"ITransientCollection")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-conj!) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-conj!")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-conj!")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientCollection"), meta=i.Meta(mid19, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid19, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IToTransient) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IToTransient")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IToTransient")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-transient) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-transient")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-transient")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid20, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid20, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/ITransientStack) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"ITransientStack")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"ITransientStack")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-push!) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-push!")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-push!")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid21, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-pop!) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-pop!")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-pop!")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid21, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid21, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IDisposable) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IDisposable")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IDisposable")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-dispose!) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-dispose!")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-dispose!")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IDisposable"), meta=i.Meta(mid22, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid22, 1)), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/IMessageObject) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"IMessageObject")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.Const(rt.wrap(u"IMessageObject")), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-get-field) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-get-field")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-get-field")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid23, 14)), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/-invoke-method) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-invoke-method")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.Const(rt.wrap(u"-invoke-method")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid23, 14)), + ], + meta=nil)]), + ], + meta=i.Meta(mid23, 1)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid24, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid24, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid24, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-get-field"), meta=i.Meta(mid24, 27)), + ], + meta=i.Meta(mid24, 1)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid25, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid25, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid25, 14)), + i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_348"), + body=i.TailCall( + args=[ + i.Lookup(kw(u"sb"), meta=i.Meta(mid26, 24)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-str"), meta=i.Meta(mid26, 28)), + i.Lookup(kw(u"x"), meta=i.Meta(mid26, 45)), + ], + meta=i.Meta(mid26, 27)), + ], + meta=i.Meta(mid26, 23)), + ), + ], + meta=i.Meta(mid25, 1)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid27, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid27, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid27, 15)), + i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_351"), + body=i.TailCall( + args=[ + i.Lookup(kw(u"sb"), meta=i.Meta(mid28, 25)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-repr"), meta=i.Meta(mid28, 29)), + i.Lookup(kw(u"x"), meta=i.Meta(mid28, 47)), + ], + meta=i.Meta(mid28, 28)), + ], + meta=i.Meta(mid28, 24)), + ), + ], + meta=i.Meta(mid27, 1)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid29, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid30, 14)), + i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"fn_354"), + body=i.TailCall( + args=[ + i.Lookup(kw(u"sb"), meta=i.Meta(mid31, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid31, 9)), + ], + meta=i.Meta(mid31, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid32, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid32, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Number"), meta=i.Meta(mid32, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-num-eq"), meta=i.Meta(mid32, 20)), + ], + meta=i.Meta(mid32, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/+) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"+")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"+")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"+"), + body=i.Const(rt.wrap(0)), + ), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"+"), + body=i.Lookup(kw(u"x"), meta=i.Meta(mid33, 8)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"+"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add"), meta=i.Meta(mid34, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid34, 16)), + i.Lookup(kw(u"y"), meta=i.Meta(mid34, 18)), + ], + meta=i.Meta(mid34, 10)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"+"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid35, 5)), + i.Lookup(kw(u"+"), meta=i.Meta(mid35, 12)), + i.Invoke( + args=[ + i.Lookup(kw(u"+"), meta=i.Meta(mid35, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid35, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid35, 19)), + ], + meta=i.Meta(mid35, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid35, 22)), + ], + meta=i.Meta(mid35, 4)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/-) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"-")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"-")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"-"), + body=i.Const(rt.wrap(0)), + ), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"-"), + body=i.Lookup(kw(u"x"), meta=i.Meta(mid36, 8)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"-"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-sub"), meta=i.Meta(mid37, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid37, 16)), + i.Lookup(kw(u"y"), meta=i.Meta(mid37, 18)), + ], + meta=i.Meta(mid37, 10)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"-"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid38, 5)), + i.Lookup(kw(u"-"), meta=i.Meta(mid38, 12)), + i.Invoke( + args=[ + i.Lookup(kw(u"-"), meta=i.Meta(mid38, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid38, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid38, 19)), + ], + meta=i.Meta(mid38, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid38, 22)), + ], + meta=i.Meta(mid38, 4)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/inc) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"inc")), + i.Fn(args=[kw(u"x")],name=kw(u"inc"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid39, 9)), + i.Lookup(kw(u"x"), meta=i.Meta(mid39, 11)), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid39, 8)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/dec) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"dec")), + i.Fn(args=[kw(u"x")],name=kw(u"dec"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid40, 9)), + i.Lookup(kw(u"x"), meta=i.Meta(mid40, 11)), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid40, 8)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/<) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"<")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"<")), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"<"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-lt"), meta=i.Meta(mid41, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid41, 15)), + i.Lookup(kw(u"y"), meta=i.Meta(mid41, 17)), + ], + meta=i.Meta(mid41, 10)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"<"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid42, 5)), + i.Lookup(kw(u"<"), meta=i.Meta(mid42, 12)), + i.Invoke( + args=[ + i.Lookup(kw(u"<"), meta=i.Meta(mid42, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid42, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid42, 19)), + ], + meta=i.Meta(mid42, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid42, 22)), + ], + meta=i.Meta(mid42, 4)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/>) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u">")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u">")), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u">"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-gt"), meta=i.Meta(mid43, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid43, 15)), + i.Lookup(kw(u"y"), meta=i.Meta(mid43, 17)), + ], + meta=i.Meta(mid43, 10)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u">"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid44, 5)), + i.Lookup(kw(u">"), meta=i.Meta(mid44, 12)), + i.Invoke( + args=[ + i.Lookup(kw(u">"), meta=i.Meta(mid44, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid44, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid44, 19)), + ], + meta=i.Meta(mid44, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid44, 22)), + ], + meta=i.Meta(mid44, 4)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/=) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"=")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"=")), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"="), + body=i.Const(nil), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"="), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"identical?"), meta=i.Meta(mid45, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid45, 26)), + i.Lookup(kw(u"y"), meta=i.Meta(mid45, 28)), + ], + meta=i.Meta(mid45, 14)), + then=i.Const(nil), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid46, 13)), + i.Lookup(kw(u"x"), meta=i.Meta(mid46, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid46, 19)), + ], + meta=i.Meta(mid46, 12)), + meta=i.Meta(mid45, 10)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"rest")],name=kw(u"="), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"eq"), meta=i.Meta(mid47, 22)), + i.Lookup(kw(u"x"), meta=i.Meta(mid47, 25)), + i.Lookup(kw(u"y"), meta=i.Meta(mid47, 27)), + ], + meta=i.Meta(mid47, 21)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid48, 20)), + i.Lookup(kw(u"="), meta=i.Meta(mid48, 26)), + i.Lookup(kw(u"y"), meta=i.Meta(mid48, 28)), + i.Lookup(kw(u"rest"), meta=i.Meta(mid48, 30)), + ], + meta=i.Meta(mid48, 19)), + els=i.Const(nil), + meta=i.Meta(mid47, 17)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/conj) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"conj")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"conj")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"conj"), + body=i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), + ), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"coll")],name=kw(u"conj"), + body=i.Lookup(kw(u"coll"), meta=i.Meta(mid49, 11)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"coll"),kw(u"itm")],name=kw(u"conj"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid50, 16)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid50, 22)), + i.Lookup(kw(u"itm"), meta=i.Meta(mid50, 27)), + ], + meta=i.Meta(mid50, 15)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"coll"),kw(u"item"),kw(u"more")],name=kw(u"conj"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid51, 5)), + i.Lookup(kw(u"conj"), meta=i.Meta(mid51, 12)), + i.Invoke( + args=[ + i.Lookup(kw(u"conj"), meta=i.Meta(mid51, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"x"), meta=i.Meta(mid51, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"y"), meta=i.Meta(mid51, 25)), + ], + meta=i.Meta(mid51, 17)), + i.Lookup(kw(u"more"), meta=i.Meta(mid51, 28)), + ], + meta=i.Meta(mid51, 4)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/count) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"count")), + i.Fn(args=[kw(u"coll")],name=kw(u"count"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid52, 12)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid52, 19)), + ], + meta=i.Meta(mid52, 11)), + )]), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/Cons) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"Cons")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), + i.Const(kw(u"Cons")), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"first")), + i.Const(kw(u"next")), + i.Const(kw(u"meta")), + ]), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/->Cons) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"->Cons")), + i.Fn(args=[kw(u"first"),kw(u"next"),kw(u"meta")],name=kw(u"->Cons"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.Lookup(kw(u"first"), meta=nil), + i.Lookup(kw(u"next"), meta=nil), + i.Lookup(kw(u"meta"), meta=nil), + ], + meta=nil), + )]), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-first"), meta=i.Meta(mid54, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.Fn(args=[kw(u"this")],name=kw(u"-first_Cons"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid54, 12)), + i.Const(kw(u"first")), + ], + meta=nil), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-next"), meta=i.Meta(mid55, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.Fn(args=[kw(u"this")],name=kw(u"-next_Cons"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid55, 11)), + i.Const(kw(u"next")), + ], + meta=nil), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid56, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.Fn(args=[kw(u"this")],name=kw(u"-seq_Cons"), + body=i.Lookup(kw(u"this"), meta=i.Meta(mid56, 16)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-meta"), meta=i.Meta(mid57, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.Fn(args=[kw(u"this")],name=kw(u"-meta_Cons"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid57, 11)), + i.Const(kw(u"meta")), + ], + meta=nil), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-with-meta"), meta=i.Meta(mid58, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.Fn(args=[kw(u"this"),kw(u"new-meta")],name=kw(u"-with-meta_Cons"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid59, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid58, 16)), + i.Const(kw(u"first")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid58, 16)), + i.Const(kw(u"next")), + ], + meta=nil), + i.Lookup(kw(u"new-meta"), meta=i.Meta(mid59, 24)), + ], + meta=i.Meta(mid59, 5)), + ), + ], + meta=nil), + ], + meta=i.Meta(mid53, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/cons) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"cons")), + i.Fn(args=[kw(u"head"),kw(u"tail")],name=kw(u"cons"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid60, 4)), + i.Lookup(kw(u"head"), meta=i.Meta(mid60, 11)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid60, 17)), + i.Lookup(kw(u"tail"), meta=i.Meta(mid60, 21)), + ], + meta=i.Meta(mid60, 16)), + i.Const(nil), + ], + meta=i.Meta(mid60, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/string-builder) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"string-builder")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"string-builder")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"string-builder"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid61, 8)), + ], + meta=i.Meta(mid61, 7)), + ), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"sb")],name=kw(u"string-builder"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid62, 10)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid62, 15)), + ], + meta=i.Meta(mid62, 9)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"sb"),kw(u"x")],name=kw(u"string-builder"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid63, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid63, 19)), + i.Lookup(kw(u"x"), meta=i.Meta(mid63, 26)), + ], + meta=i.Meta(mid63, 8)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid64, 7)), + i.Lookup(kw(u"x"), meta=i.Meta(mid64, 30)), + ], + meta=i.Meta(mid64, 6)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-bulder"), meta=i.Meta(mid65, 7)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid65, 30)), + i.Lookup(kw(u"x"), meta=i.Meta(mid65, 35)), + ], + meta=i.Meta(mid65, 29)), + ], + meta=i.Meta(mid65, 6)), + meta=i.Meta(mid63, 4)), + ), + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/str) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"str")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(0)), + i.Fn(args=[kw(u"args")],name=kw(u"str"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid66, 4)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"map"), meta=i.Meta(mid67, 5)), + i.Lookup(kw(u"str"), meta=i.Meta(mid67, 9)), + ], + meta=i.Meta(mid67, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"string-builder"), meta=i.Meta(mid68, 4)), + i.Lookup(kw(u"args"), meta=i.Meta(mid69, 4)), + ], + meta=i.Meta(mid66, 3)), + )])]), + i.Invoke(args=[ +# (def pixie.stdlib/println) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"println")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(0)), + i.Fn(args=[kw(u"args")],name=kw(u"println"),closed_overs=[kw(u"add-fn"),kw(u"sb")], + body=i.Let(names=[kw(u"sb"),kw(u"add-fn")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid70, 13)), + ], + meta=i.Meta(mid70, 12)), + i.Fn(args=[kw(u"x")],name=kw(u"fn_410"),closed_overs=[kw(u"sb")], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid71, 19)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid71, 42)), + i.Lookup(kw(u"x"), meta=i.Meta(mid71, 45)), + ], + meta=i.Meta(mid71, 18)), + ), + ], + body=i.Do( + args=[ + i.Let(names=[kw(u"idx"),kw(u"sb")], + bindings=[ + i.Const(rt.wrap(0)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid72, 15)), + ], + body=i.Invoke( + args=[ + i.Fn(args=[kw(u"idx"),kw(u"sb")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"args"),kw(u"add-fn")], + body=i.Let(names=[kw(u"idx"),kw(u"sb")], + bindings=[ + i.Lookup(kw(u"idx"), meta=i.Meta(mid73, 12)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid72, 12)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid74, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid74, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid74, 19)), + i.Lookup(kw(u"args"), meta=i.Meta(mid74, 25)), + ], + meta=i.Meta(mid74, 18)), + ], + meta=i.Meta(mid74, 11)), + then=i.TailCall( + args=[ + i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid75, 17)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid75, 21)), + ], + meta=i.Meta(mid75, 16)), + i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid76, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid76, 27)), + i.Lookup(kw(u"args"), meta=i.Meta(mid76, 32)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid76, 37)), + ], + meta=i.Meta(mid76, 26)), + i.Lookup(kw(u"add-fn"), meta=i.Meta(mid76, 42)), + ], + meta=i.Meta(mid76, 20)), + i.Invoke( + args=[ + i.Lookup(kw(u"add-fn"), meta=i.Meta(mid77, 21)), + i.Const(rt.wrap(u" ")), + ], + meta=i.Meta(mid77, 20)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid78, 18)), + ], + meta=i.Meta(mid76, 16)), + ], + meta=nil), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-blocking-println"), meta=i.Meta(mid79, 10)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-finish-string-builder"), meta=i.Meta(mid79, 29)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid79, 52)), + ], + meta=i.Meta(mid79, 28)), + ], + meta=i.Meta(mid79, 9)), + meta=i.Meta(mid74, 7)), + meta=nil), + ), + i.Lookup(kw(u"idx"), meta=i.Meta(mid73, 12)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid72, 12)), + ], + meta=nil), + meta=i.Meta(mid73, 5)), + i.Const(nil), + ], + meta=nil), + meta=i.Meta(mid70, 3)), + )])]), + i.Invoke(args=[ +# (def pixie.stdlib/instance?) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"instance?")), + i.Fn(args=[kw(u"t"),kw(u"x")],name=kw(u"instance?"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid80, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid80, 20)), + i.Lookup(kw(u"t"), meta=i.Meta(mid80, 29)), + ], + meta=i.Meta(mid80, 7)), + then=i.Let(names=[kw(u"ts")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid81, 15)), + i.Lookup(kw(u"t"), meta=i.Meta(mid81, 19)), + ], + meta=i.Meta(mid81, 14)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid82, 12)), + i.Lookup(kw(u"ts"), meta=i.Meta(mid82, 16)), + ], + meta=i.Meta(mid82, 11)), + then=i.Const(nil), + els=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid83, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid83, 28)), + i.Lookup(kw(u"ts"), meta=i.Meta(mid83, 34)), + ], + meta=i.Meta(mid83, 27)), + i.Lookup(kw(u"x"), meta=i.Meta(mid83, 38)), + ], + meta=i.Meta(mid83, 15)), + then=i.Const(nil), + els=i.TailCall( + args=[ + i.Lookup(kw(u"instance?"), meta=i.Meta(mid84, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid84, 25)), + i.Lookup(kw(u"ts"), meta=i.Meta(mid84, 30)), + ], + meta=i.Meta(mid84, 24)), + i.Lookup(kw(u"x"), meta=i.Meta(mid84, 34)), + ], + meta=i.Meta(mid84, 13)), + meta=i.Meta(mid83, 11)), + meta=i.Meta(mid82, 7)), + meta=i.Meta(mid81, 5)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid85, 6)), + i.Lookup(kw(u"t"), meta=i.Meta(mid85, 17)), + i.Lookup(kw(u"x"), meta=i.Meta(mid85, 19)), + ], + meta=i.Meta(mid85, 5)), + meta=i.Meta(mid80, 3)), + )]), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/Reduced) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"Reduced")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), + i.Const(kw(u"Reduced")), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"x")), + ]), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/->Reduced) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"->Reduced")), + i.Fn(args=[kw(u"x")],name=kw(u"->Reduced"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid86, 10)), + i.Lookup(kw(u"x"), meta=nil), + ], + meta=nil), + )]), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=i.Meta(mid87, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid86, 10)), + i.Fn(args=[kw(u"this")],name=kw(u"-deref_Reduced"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid87, 12)), + i.Const(kw(u"x")), + ], + meta=nil), + ), + ], + meta=nil), + ], + meta=i.Meta(mid86, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/reduced) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"reduced")), + i.Fn(args=[kw(u"x")],name=kw(u"reduced"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Reduced"), meta=i.Meta(mid88, 4)), + i.Lookup(kw(u"x"), meta=i.Meta(mid88, 14)), + ], + meta=i.Meta(mid88, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/reduced?) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"reduced?")), + i.Fn(args=[kw(u"x")],name=kw(u"reduced?"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid89, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid89, 14)), + i.Lookup(kw(u"x"), meta=i.Meta(mid89, 22)), + ], + meta=i.Meta(mid89, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/satisfies?) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"satisfies?")), + i.Fn(args=[kw(u"p"),kw(u"x")],name=kw(u"satisfies?"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid90, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid90, 20)), + i.Lookup(kw(u"p"), meta=i.Meta(mid90, 29)), + ], + meta=i.Meta(mid90, 7)), + then=i.Let(names=[kw(u"ps")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid91, 15)), + i.Lookup(kw(u"p"), meta=i.Meta(mid91, 19)), + ], + meta=i.Meta(mid91, 14)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid92, 12)), + i.Lookup(kw(u"ps"), meta=i.Meta(mid92, 16)), + ], + meta=i.Meta(mid92, 11)), + then=i.Const(nil), + els=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid93, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid93, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid93, 34)), + i.Lookup(kw(u"ps"), meta=i.Meta(mid93, 40)), + ], + meta=i.Meta(mid93, 33)), + i.Lookup(kw(u"x"), meta=i.Meta(mid93, 44)), + ], + meta=i.Meta(mid93, 20)), + ], + meta=i.Meta(mid93, 15)), + then=i.Const(nil), + els=i.TailCall( + args=[ + i.Lookup(kw(u"satisfies?"), meta=i.Meta(mid94, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid94, 26)), + i.Lookup(kw(u"ps"), meta=i.Meta(mid94, 31)), + ], + meta=i.Meta(mid94, 25)), + i.Lookup(kw(u"x"), meta=i.Meta(mid94, 35)), + ], + meta=i.Meta(mid94, 13)), + meta=i.Meta(mid93, 11)), + meta=i.Meta(mid92, 7)), + meta=i.Meta(mid91, 5)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid95, 6)), + i.Lookup(kw(u"p"), meta=i.Meta(mid95, 18)), + i.Lookup(kw(u"x"), meta=i.Meta(mid95, 20)), + ], + meta=i.Meta(mid95, 5)), + meta=i.Meta(mid90, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/transduce) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"transduce")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"transduce")), + i.Const(rt.wrap(3)), i.Fn(args=[kw(u"xform"),kw(u"rf"),kw(u"coll")],name=kw(u"transduce"), + body=i.Let(names=[kw(u"f"),kw(u"result")], + bindings=[ + i.Invoke( + args=[ + i.Lookup(kw(u"xform"), meta=i.Meta(mid96, 13)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid96, 19)), + ], + meta=i.Meta(mid96, 12)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid97, 18)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid97, 26)), + i.Lookup(kw(u"f"), meta=i.Meta(mid97, 31)), + i.Invoke( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid97, 34)), + ], + meta=i.Meta(mid97, 33)), + ], + meta=i.Meta(mid97, 17)), + ], + body=i.TailCall( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid98, 7)), + i.Lookup(kw(u"result"), meta=i.Meta(mid98, 9)), + ], + meta=i.Meta(mid98, 6)), + meta=i.Meta(mid96, 4)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"f"),kw(u"coll")],name=kw(u"transduce"), + body=i.Let(names=[kw(u"result")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid99, 18)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid99, 26)), + i.Lookup(kw(u"f"), meta=i.Meta(mid99, 31)), + i.Invoke( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid99, 34)), + ], + meta=i.Meta(mid99, 33)), + ], + meta=i.Meta(mid99, 17)), + ], + body=i.TailCall( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid100, 7)), + i.Lookup(kw(u"result"), meta=i.Meta(mid100, 9)), + ], + meta=i.Meta(mid100, 6)), + meta=i.Meta(mid99, 4)), + ), + i.Const(rt.wrap(4)), i.Fn(args=[kw(u"xform"),kw(u"rf"),kw(u"init"),kw(u"coll")],name=kw(u"transduce"), + body=i.Let(names=[kw(u"f"),kw(u"result")], + bindings=[ + i.Invoke( + args=[ + i.Lookup(kw(u"xform"), meta=i.Meta(mid101, 13)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid101, 19)), + ], + meta=i.Meta(mid101, 12)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid102, 18)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid102, 26)), + i.Lookup(kw(u"f"), meta=i.Meta(mid102, 31)), + i.Lookup(kw(u"init"), meta=i.Meta(mid102, 33)), + ], + meta=i.Meta(mid102, 17)), + ], + body=i.TailCall( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid103, 7)), + i.Lookup(kw(u"result"), meta=i.Meta(mid103, 9)), + ], + meta=i.Meta(mid103, 6)), + meta=i.Meta(mid101, 4)), + ), + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/reduce) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"reduce")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"reduce")), + i.Const(rt.wrap(3)), i.Fn(args=[kw(u"rf"),kw(u"init"),kw(u"col")],name=kw(u"reduce"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid104, 5)), + i.Lookup(kw(u"col"), meta=i.Meta(mid104, 13)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid104, 17)), + i.Lookup(kw(u"init"), meta=i.Meta(mid104, 20)), + ], + meta=i.Meta(mid104, 4)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"rf"),kw(u"col")],name=kw(u"reduce"), + body=i.TailCall( + args=[ + i.Lookup(kw(u"reduce"), meta=i.Meta(mid105, 5)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid105, 12)), + i.Invoke( + args=[ + i.Lookup(kw(u"rf"), meta=i.Meta(mid105, 16)), + ], + meta=i.Meta(mid105, 15)), + i.Lookup(kw(u"col"), meta=i.Meta(mid105, 20)), + ], + meta=i.Meta(mid105, 4)), + ), + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/into) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"into")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"into")), + i.Const(rt.wrap(3)), i.Fn(args=[kw(u"to"),kw(u"xform"),kw(u"from")],name=kw(u"into"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid106, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid106, 20)), + i.Lookup(kw(u"to"), meta=i.Meta(mid106, 33)), + ], + meta=i.Meta(mid106, 8)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid107, 7)), + i.Lookup(kw(u"xform"), meta=i.Meta(mid107, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid107, 23)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid107, 30)), + i.Lookup(kw(u"to"), meta=i.Meta(mid107, 40)), + ], + meta=i.Meta(mid107, 29)), + i.Lookup(kw(u"from"), meta=i.Meta(mid107, 44)), + ], + meta=i.Meta(mid107, 6)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid108, 7)), + i.Lookup(kw(u"xform"), meta=i.Meta(mid108, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid108, 23)), + i.Lookup(kw(u"to"), meta=i.Meta(mid108, 28)), + i.Lookup(kw(u"from"), meta=i.Meta(mid108, 31)), + ], + meta=i.Meta(mid108, 6)), + meta=i.Meta(mid106, 4)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"to"),kw(u"from")],name=kw(u"into"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid109, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid109, 20)), + i.Lookup(kw(u"to"), meta=i.Meta(mid109, 33)), + ], + meta=i.Meta(mid109, 8)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"persistent!"), meta=i.Meta(mid110, 7)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid110, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid110, 27)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid110, 34)), + i.Lookup(kw(u"to"), meta=i.Meta(mid110, 44)), + ], + meta=i.Meta(mid110, 33)), + i.Lookup(kw(u"from"), meta=i.Meta(mid110, 48)), + ], + meta=i.Meta(mid110, 19)), + ], + meta=i.Meta(mid110, 6)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid111, 7)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid111, 14)), + i.Lookup(kw(u"to"), meta=i.Meta(mid111, 19)), + i.Lookup(kw(u"from"), meta=i.Meta(mid111, 22)), + ], + meta=i.Meta(mid111, 6)), + meta=i.Meta(mid109, 4)), + ), + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/map) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"map")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"map")), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"f")],name=kw(u"map"), + body=i.Fn(args=[kw(u"xf")],name=kw(u"fn_447"),closed_overs=[kw(u"f")], + body=i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"fn_451")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"fn_451"),closed_overs=[kw(u"xf")], + body=i.TailCall( + args=[ + i.Lookup(kw(u"xf"), meta=i.Meta(mid112, 13)), + ], + meta=i.Meta(mid112, 12)), + ), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"result")],name=kw(u"fn_451"),closed_overs=[kw(u"xf")], + body=i.TailCall( + args=[ + i.Lookup(kw(u"xf"), meta=i.Meta(mid113, 19)), + i.Lookup(kw(u"result"), meta=i.Meta(mid113, 22)), + ], + meta=i.Meta(mid113, 18)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"result"),kw(u"item")],name=kw(u"fn_451"),closed_overs=[kw(u"xf"),kw(u"f")], + body=i.TailCall( + args=[ + i.Lookup(kw(u"xf"), meta=i.Meta(mid114, 24)), + i.Lookup(kw(u"result"), meta=i.Meta(mid114, 27)), + i.Invoke( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid114, 35)), + i.Lookup(kw(u"item"), meta=i.Meta(mid114, 37)), + ], + meta=i.Meta(mid114, 34)), + ], + meta=i.Meta(mid114, 23)), + ), + ]), + ), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"f"),kw(u"coll")],name=kw(u"map"),closed_overs=[kw(u"map")], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid115, 5)), + i.Fn(args=[],name=kw(u"fn_452"),closed_overs=[kw(u"map"),kw(u"f"),kw(u"coll")], + body=i.Let(names=[kw(u"s")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid116, 16)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid116, 20)), + ], + meta=i.Meta(mid116, 15)), + ], + body=i.If( + test=i.Lookup(kw(u"s"), meta=i.Meta(mid117, 13)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid118, 12)), + i.Invoke( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid118, 18)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid118, 21)), + i.Lookup(kw(u"s"), meta=i.Meta(mid118, 27)), + ], + meta=i.Meta(mid118, 20)), + ], + meta=i.Meta(mid118, 17)), + i.Invoke( + args=[ + i.Lookup(kw(u"map"), meta=i.Meta(mid119, 18)), + i.Lookup(kw(u"f"), meta=i.Meta(mid119, 22)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid119, 25)), + i.Lookup(kw(u"s"), meta=i.Meta(mid119, 30)), + ], + meta=i.Meta(mid119, 24)), + ], + meta=i.Meta(mid119, 17)), + ], + meta=i.Meta(mid118, 11)), + els=i.Const(nil), + meta=i.Meta(mid117, 9)), + meta=i.Meta(mid116, 7)), + ), + ], + meta=i.Meta(mid115, 4)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(1)), + i.Fn(args=[kw(u"f"),kw(u"colls")],name=kw(u"map"),closed_overs=[kw(u"step"),kw(u"map")], + body=i.Let(names=[kw(u"step")], + bindings=[ + i.Fn(args=[kw(u"cs")],name=kw(u"step"),closed_overs=[kw(u"step"),kw(u"map")], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid120, 18)), + i.Fn(args=[],name=kw(u"fn_454"),closed_overs=[kw(u"step"),kw(u"map"),kw(u"cs")], + body=i.Let(names=[kw(u"ss")], + bindings=[ + i.Invoke( + args=[ + i.Lookup(kw(u"map"), meta=i.Meta(mid121, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid121, 34)), + i.Lookup(kw(u"cs"), meta=i.Meta(mid121, 38)), + ], + meta=i.Meta(mid121, 29)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"every?"), meta=i.Meta(mid122, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"identity"), meta=i.Meta(mid122, 34)), + i.Lookup(kw(u"ss"), meta=i.Meta(mid122, 43)), + ], + meta=i.Meta(mid122, 26)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid123, 25)), + i.Invoke( + args=[ + i.Lookup(kw(u"map"), meta=i.Meta(mid123, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid123, 35)), + i.Lookup(kw(u"ss"), meta=i.Meta(mid123, 41)), + ], + meta=i.Meta(mid123, 30)), + i.Invoke( + args=[ + i.Lookup(kw(u"step"), meta=i.Meta(mid123, 46)), + i.Invoke( + args=[ + i.Lookup(kw(u"map"), meta=i.Meta(mid123, 52)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid123, 56)), + i.Lookup(kw(u"ss"), meta=i.Meta(mid123, 61)), + ], + meta=i.Meta(mid123, 51)), + ], + meta=i.Meta(mid123, 45)), + ], + meta=i.Meta(mid123, 24)), + els=i.Const(nil), + meta=i.Meta(mid122, 22)), + meta=i.Meta(mid121, 20)), + ), + ], + meta=i.Meta(mid120, 17)), + ), + ], + body=i.TailCall( + args=[ + i.Lookup(kw(u"map"), meta=i.Meta(mid124, 7)), + i.Fn(args=[kw(u"args")],name=kw(u"fn_456"),closed_overs=[kw(u"f")], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid124, 23)), + i.Lookup(kw(u"f"), meta=i.Meta(mid124, 29)), + i.Lookup(kw(u"args"), meta=i.Meta(mid124, 31)), + ], + meta=i.Meta(mid124, 22)), + ), + i.Invoke( + args=[ + i.Lookup(kw(u"step"), meta=i.Meta(mid124, 39)), + i.Lookup(kw(u"colls"), meta=i.Meta(mid124, 44)), + ], + meta=i.Meta(mid124, 38)), + ], + meta=i.Meta(mid124, 6)), + meta=i.Meta(mid125, 4)), + )]) + ])]), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/Range) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"Range")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), + i.Const(kw(u"Range")), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"start")), + i.Const(kw(u"stop")), + i.Const(kw(u"step")), + ]), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/->Range) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"->Range")), + i.Fn(args=[kw(u"start"),kw(u"stop"),kw(u"step")],name=kw(u"->Range"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Lookup(kw(u"start"), meta=nil), + i.Lookup(kw(u"stop"), meta=nil), + i.Lookup(kw(u"step"), meta=nil), + ], + meta=nil), + )]), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid127, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"self"),kw(u"f"),kw(u"init")],name=kw(u"-reduce_Range"), + body=i.Let(names=[kw(u"i"),kw(u"acc")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Lookup(kw(u"init"), meta=i.Meta(mid128, 16)), + ], + body=i.TailCall( + args=[ + i.Fn(args=[kw(u"i"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"self"),kw(u"f")], + body=i.Let(names=[kw(u"i"),kw(u"acc")], + bindings=[ + i.Lookup(kw(u"i"), meta=i.Meta(mid129, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid128, 12)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid130, 8)), + i.Lookup(kw(u"i"), meta=i.Meta(mid130, 16)), + ], + meta=i.Meta(mid130, 7)), + i.If( + test=i.Let(names=[kw(u"r#__gensym_321")], + bindings=[ + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid131, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid131, 20)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid131, 32)), + i.Lookup(kw(u"i"), meta=i.Meta(mid131, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid131, 31)), + els=i.Const(nil), + meta=i.Meta(mid131, 15)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_321"), meta=nil), + els=i.Let(names=[kw(u"r#__gensym_320")], + bindings=[ + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid132, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid132, 20)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid132, 32)), + i.Lookup(kw(u"i"), meta=i.Meta(mid132, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid132, 31)), + els=i.Const(nil), + meta=i.Meta(mid132, 15)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid133, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid133, 15)), + meta=nil), + meta=nil), + meta=nil), + meta=i.Meta(mid131, 11)), + then=i.Let(names=[kw(u"acc")], + bindings=[ + i.Invoke( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid134, 20)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid134, 22)), + i.Lookup(kw(u"i"), meta=i.Meta(mid134, 26)), + ], + meta=i.Meta(mid134, 19)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid135, 16)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid135, 25)), + ], + meta=i.Meta(mid135, 15)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), + i.Lookup(kw(u"acc"), meta=i.Meta(mid136, 14)), + ], + meta=i.Meta(mid136, 13)), + els=i.TailCall( + args=[ + i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid137, 21)), + i.Lookup(kw(u"i"), meta=i.Meta(mid137, 23)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Const(kw(u"step")), + ], + meta=nil), + ], + meta=i.Meta(mid137, 20)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid137, 31)), + ], + meta=nil), + meta=i.Meta(mid135, 11)), + meta=i.Meta(mid134, 9)), + els=i.Lookup(kw(u"acc"), meta=i.Meta(mid138, 9)), + meta=i.Meta(mid131, 7)), + ], + meta=nil), + meta=nil), + ), + i.Lookup(kw(u"i"), meta=i.Meta(mid129, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid128, 12)), + ], + meta=nil), + meta=i.Meta(mid129, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid139, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"self")],name=kw(u"-count_Range"), + body=i.If( + test=i.Let(names=[kw(u"r#__gensym_321")], + bindings=[ + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid140, 19)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid140, 18)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid140, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid140, 33)), + els=i.Const(nil), + meta=i.Meta(mid140, 13)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_321"), meta=nil), + els=i.Let(names=[kw(u"r#__gensym_320")], + bindings=[ + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid141, 19)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid141, 18)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid141, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid141, 33)), + els=i.Const(nil), + meta=i.Meta(mid141, 13)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid142, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid142, 13)), + meta=nil), + meta=nil), + meta=nil), + meta=i.Meta(mid140, 9)), + then=i.Const(rt.wrap(0)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"abs"), meta=i.Meta(mid143, 8)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"quot"), meta=i.Meta(mid143, 13)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid143, 19)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid143, 18)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Const(kw(u"step")), + ], + meta=nil), + ], + meta=i.Meta(mid143, 12)), + ], + meta=i.Meta(mid143, 7)), + meta=i.Meta(mid140, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid144, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"self"),kw(u"idx")],name=kw(u"-nth_Range"), + body=i.If( + test=i.Let(names=[kw(u"r#__gensym_320")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid145, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid144, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid144, 10)), + i.Const(kw(u"stop")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid145, 15)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"neg?"), meta=i.Meta(mid145, 33)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid145, 38)), + ], + meta=i.Meta(mid145, 32)), + meta=nil), + meta=i.Meta(mid145, 11)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid146, 8)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), + i.Const(rt.wrap(u"Index out of Range")), + ]), + ], + meta=i.Meta(mid146, 7)), + els=i.Const(nil), + meta=i.Meta(mid145, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid147, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"self"),kw(u"idx"),kw(u"not-found")],name=kw(u"-nth-not-found_Range"), + body=i.Let(names=[kw(u"cmp"),kw(u"val")], + bindings=[ + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid148, 19)), + then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 34)), + els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid148, 36)), + meta=i.Meta(mid148, 15)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid149, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid149, 25)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid149, 27)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Const(kw(u"step")), + ], + meta=nil), + ], + meta=i.Meta(mid149, 24)), + ], + meta=i.Meta(mid149, 15)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.Lookup(kw(u"cmp"), meta=i.Meta(mid150, 12)), + i.Lookup(kw(u"val"), meta=i.Meta(mid150, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid150, 11)), + then=i.Lookup(kw(u"val"), meta=i.Meta(mid151, 9)), + els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid152, 8)), + meta=i.Meta(mid150, 7)), + meta=i.Meta(mid148, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid153, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"self")],name=kw(u"-seq_Range"), + body=i.If( + test=i.Let(names=[kw(u"r#__gensym_320")], + bindings=[ + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid154, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid154, 20)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid154, 32)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid154, 31)), + els=i.Const(nil), + meta=i.Meta(mid154, 15)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + els=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid155, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid155, 20)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid155, 32)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid155, 31)), + els=i.Const(nil), + meta=i.Meta(mid155, 15)), + meta=nil), + meta=i.Meta(mid154, 11)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid156, 8)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid156, 20)), + i.Fn(args=[],name=kw(u"fn_475"),closed_overs=[kw(u"self")], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid156, 32)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid156, 39)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"step")), + ], + meta=nil), + ], + meta=i.Meta(mid156, 38)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"stop")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Const(kw(u"step")), + ], + meta=nil), + ], + meta=i.Meta(mid156, 31)), + ), + ], + meta=i.Meta(mid156, 19)), + ], + meta=i.Meta(mid156, 7)), + els=i.Const(nil), + meta=i.Meta(mid154, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid157, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-str_Range"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid158, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid158, 12)), + i.Lookup(kw(u"this"), meta=i.Meta(mid158, 16)), + ], + meta=i.Meta(mid158, 11)), + i.Lookup(kw(u"sbf"), meta=i.Meta(mid158, 22)), + ], + meta=i.Meta(mid158, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid159, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-repr_Range"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid160, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid160, 13)), + i.Lookup(kw(u"this"), meta=i.Meta(mid160, 17)), + ], + meta=i.Meta(mid160, 12)), + i.Lookup(kw(u"sbf"), meta=i.Meta(mid160, 23)), + ], + meta=i.Meta(mid160, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid161, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"-eq_Range"), + body=i.Const(nil), + ), + ], + meta=nil), + ], + meta=i.Meta(mid126, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/MAX-NUMBER) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"MAX-NUMBER")), + i.Const(rt.wrap(4294967295))]), + i.Invoke(args=[ +# (def pixie.stdlib/range) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"range")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"range")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"range"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid162, 8)), + i.Const(rt.wrap(0)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"MAX-NUMBER"), meta=i.Meta(mid162, 18)), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid162, 7)), + ), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"stop")],name=kw(u"range"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid163, 12)), + i.Const(rt.wrap(0)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid163, 22)), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid163, 11)), + ), + i.Const(rt.wrap(3)), i.Fn(args=[kw(u"start"),kw(u"stop"),kw(u"step")],name=kw(u"range"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid164, 23)), + i.Lookup(kw(u"start"), meta=i.Meta(mid164, 31)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid164, 37)), + i.Lookup(kw(u"step"), meta=i.Meta(mid164, 42)), + ], + meta=i.Meta(mid164, 22)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"start"),kw(u"stop")],name=kw(u"range"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid165, 18)), + i.Lookup(kw(u"start"), meta=i.Meta(mid165, 26)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid165, 32)), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid165, 17)), + ), + ])]), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/Node) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"Node")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), + i.Const(kw(u"Node")), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"edit")), + i.Const(kw(u"array")), + ]), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/->Node) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"->Node")), + i.Fn(args=[kw(u"edit"),kw(u"array")],name=kw(u"->Node"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid166, 10)), + i.Lookup(kw(u"edit"), meta=nil), + i.Lookup(kw(u"array"), meta=nil), + ], + meta=nil), + )]), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid167, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid166, 10)), + i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_Node"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid168, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid168, 16)), + i.Lookup(kw(u"name"), meta=i.Meta(mid168, 21)), + ], + meta=i.Meta(mid168, 5)), + ), + ], + meta=nil), + ], + meta=i.Meta(mid166, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/new-node) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"new-node")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"new-node")), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"edit")],name=kw(u"new-node"), + body=i.TailCall( + args=[ + i.Lookup(kw(u"new-node"), meta=i.Meta(mid169, 5)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid169, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid169, 20)), + i.Const(rt.wrap(32)), + ], + meta=i.Meta(mid169, 19)), + ], + meta=i.Meta(mid169, 4)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"edit"),kw(u"array")],name=kw(u"new-node"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid170, 5)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid170, 12)), + i.Lookup(kw(u"array"), meta=i.Meta(mid170, 17)), + ], + meta=i.Meta(mid170, 4)), + ), + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/EMPTY-NODE) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY-NODE")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid171, 18)), + i.Const(nil), + ], + meta=i.Meta(mid171, 17))]), + i.Invoke(args=[ +# (def pixie.stdlib/tailoff) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"tailoff")), + i.Fn(args=[kw(u"this")],name=kw(u"tailoff"), + body=i.Let(names=[kw(u"cnt")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid172, 20)), + i.Const(kw(u"cnt")), + ], + meta=i.Meta(mid172, 13)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid173, 10)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid173, 12)), + i.Const(rt.wrap(32)), + ], + meta=i.Meta(mid173, 9)), + then=i.Const(rt.wrap(0)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid174, 8)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid174, 24)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid174, 41)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid174, 45)), + ], + meta=i.Meta(mid174, 40)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid174, 23)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid174, 7)), + meta=i.Meta(mid173, 5)), + meta=i.Meta(mid172, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/array-for) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"array-for")), + i.Fn(args=[kw(u"this"),kw(u"i"),kw(u"cnt"),kw(u"root"),kw(u"shift"),kw(u"tail")],name=kw(u"array-for"), + body=i.If( + test=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid175, 17)), + i.Const(rt.wrap(0)), + i.Lookup(kw(u"i"), meta=i.Meta(mid175, 22)), + ], + meta=i.Meta(mid175, 16)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid175, 26)), + i.Lookup(kw(u"i"), meta=i.Meta(mid175, 28)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid175, 30)), + ], + meta=i.Meta(mid175, 25)), + els=i.Const(nil), + meta=i.Meta(mid175, 11)), + then=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">="), meta=i.Meta(mid176, 14)), + i.Lookup(kw(u"i"), meta=i.Meta(mid176, 17)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid176, 20)), + i.Lookup(kw(u"this"), meta=i.Meta(mid176, 28)), + ], + meta=i.Meta(mid176, 19)), + ], + meta=i.Meta(mid176, 13)), + then=i.Lookup(kw(u"tail"), meta=i.Meta(mid177, 11)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Invoke( + args=[ + i.Fn(args=[kw(u"node"),kw(u"level")],name=kw(u"look-deeper"),closed_overs=[kw(u"i")], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid178, 28)), + i.Lookup(kw(u"level"), meta=i.Meta(mid178, 30)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid178, 27)), + then=i.TailCall( + args=[ + i.Lookup(kw(u"look-deeper"), meta=i.Meta(mid179, 26)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid179, 39)), + i.Invoke( + args=[ + i.Const(kw(u"array")), + i.Lookup(kw(u"node"), meta=i.Meta(mid179, 52)), + ], + meta=i.Meta(mid179, 44)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid180, 45)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid180, 54)), + i.Lookup(kw(u"i"), meta=i.Meta(mid180, 70)), + i.Lookup(kw(u"level"), meta=i.Meta(mid180, 72)), + ], + meta=i.Meta(mid180, 53)), + i.Const(rt.wrap(31)), + ], + meta=i.Meta(mid180, 44)), + ], + meta=i.Meta(mid179, 38)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid181, 39)), + i.Lookup(kw(u"level"), meta=i.Meta(mid181, 41)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid181, 38)), + ], + meta=i.Meta(mid179, 25)), + els=i.TailCall( + args=[ + i.Const(kw(u"array")), + i.Lookup(kw(u"node"), meta=i.Meta(mid182, 33)), + ], + meta=i.Meta(mid182, 25)), + meta=i.Meta(mid178, 23)), + ), + i.Lookup(kw(u"root"), meta=i.Meta(mid183, 21)), + i.Lookup(kw(u"shift"), meta=i.Meta(mid184, 21)), + ], + meta=i.Meta(mid185, 20)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid185, 11)), + meta=i.Meta(mid176, 9)), + els=i.Const(nil), + meta=i.Meta(mid175, 7)), + )]), + i.Do( + args=[ + i.Invoke(args=[ +# (def pixie.stdlib/PersistentVector) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"PersistentVector")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), + i.Const(kw(u"PersistentVector")), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"cnt")), + i.Const(kw(u"shift")), + i.Const(kw(u"root")), + i.Const(kw(u"tail")), + i.Const(kw(u"meta")), + ]), + ], + meta=nil)]), + i.Invoke(args=[ +# (def pixie.stdlib/->PersistentVector) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"->PersistentVector")), + i.Fn(args=[kw(u"cnt"),kw(u"shift"),kw(u"root"),kw(u"tail"),kw(u"meta")],name=kw(u"->PersistentVector"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.Lookup(kw(u"cnt"), meta=nil), + i.Lookup(kw(u"shift"), meta=nil), + i.Lookup(kw(u"root"), meta=nil), + i.Lookup(kw(u"tail"), meta=nil), + i.Lookup(kw(u"meta"), meta=nil), + ], + meta=nil), + )]), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid187, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_PersistentVector"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid188, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid188, 16)), + i.Lookup(kw(u"name"), meta=i.Meta(mid188, 21)), + ], + meta=i.Meta(mid188, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid189, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.Fn(args=[kw(u"this"),kw(u"val")],name=kw(u"-conj_PersistentVector"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid190, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid189, 11)), + i.Const(kw(u"cnt")), + ], + meta=nil), + i.Const(rt.wrap(4294967295)), + ], + meta=i.Meta(mid190, 13)), + then=i.Const(nil), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=nil), + i.Const(rt.wrap(u"Assert failed: ")), + i.Const(rt.wrap(u"Vector too large")), + ], + meta=nil), + ]), + ], + meta=nil), + meta=i.Meta(mid190, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid191, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.Fn(args=[kw(u"this")],name=kw(u"-count_PersistentVector"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid191, 12)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ), + ], + meta=nil), + ], + meta=i.Meta(mid186, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/push-tail) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"push-tail")), + i.Fn(args=[kw(u"this"),kw(u"level"),kw(u"parent"),kw(u"tail-node")],name=kw(u"push-tail"), + body=i.Let(names=[kw(u"subidx"),kw(u"ret-array"),kw(u"node-to-insert")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid192, 17)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid192, 26)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid192, 43)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid192, 54)), + i.Const(kw(u"cnt")), + ], + meta=i.Meta(mid192, 47)), + ], + meta=i.Meta(mid192, 42)), + i.Lookup(kw(u"level"), meta=i.Meta(mid192, 61)), + ], + meta=i.Meta(mid192, 25)), + i.Const(rt.wrap(31)), + ], + meta=i.Meta(mid192, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aclone"), meta=i.Meta(mid193, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Lookup(kw(u"parent"), meta=i.Meta(mid193, 36)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid193, 27)), + ], + meta=i.Meta(mid193, 19)), + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid194, 29)), + i.Lookup(kw(u"level"), meta=i.Meta(mid194, 31)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid194, 28)), + then=i.Lookup(kw(u"tail-node"), meta=i.Meta(mid195, 26)), + els=i.Let(names=[kw(u"child")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid196, 39)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Lookup(kw(u"parent"), meta=i.Meta(mid196, 53)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid196, 44)), + i.Lookup(kw(u"subidx"), meta=i.Meta(mid196, 61)), + ], + meta=i.Meta(mid196, 38)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid197, 33)), + i.Lookup(kw(u"child"), meta=i.Meta(mid197, 35)), + i.Const(nil), + ], + meta=i.Meta(mid197, 32)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid198, 31)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid198, 56)), + i.Const(kw(u"root")), + ], + meta=i.Meta(mid198, 48)), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid198, 40)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid199, 41)), + i.Lookup(kw(u"level"), meta=i.Meta(mid199, 43)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid199, 40)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid200, 40)), + ], + meta=i.Meta(mid198, 30)), + els=i.Invoke( + args=[ + i.Lookup(kw(u"push-tail"), meta=i.Meta(mid201, 31)), + i.Lookup(kw(u"this"), meta=i.Meta(mid201, 41)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid202, 42)), + i.Lookup(kw(u"level"), meta=i.Meta(mid202, 44)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid202, 41)), + i.Lookup(kw(u"child"), meta=i.Meta(mid203, 41)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid204, 41)), + ], + meta=i.Meta(mid201, 30)), + meta=i.Meta(mid197, 28)), + meta=i.Meta(mid196, 26)), + meta=i.Meta(mid194, 24)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid205, 6)), + i.Lookup(kw(u"ret-array"), meta=i.Meta(mid205, 11)), + i.Lookup(kw(u"subidx"), meta=i.Meta(mid205, 21)), + i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid205, 28)), + ], + meta=i.Meta(mid205, 5)), + i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid206, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Lookup(kw(u"parent"), meta=i.Meta(mid206, 21)), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid206, 13)), + i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid206, 29)), + ], + meta=i.Meta(mid206, 5)), + ], + meta=nil), + meta=i.Meta(mid192, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/new-path) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"new-path")), + i.Fn(args=[kw(u"edit"),kw(u"level"),kw(u"node")],name=kw(u"new-path"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid207, 8)), + i.Lookup(kw(u"level"), meta=i.Meta(mid207, 10)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid207, 7)), + then=i.Lookup(kw(u"node"), meta=i.Meta(mid208, 5)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid209, 6)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid209, 13)), + i.Invoke( + args=[ + i.Lookup(kw(u"new-path"), meta=i.Meta(mid210, 14)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid210, 23)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid210, 29)), + i.Lookup(kw(u"level"), meta=i.Meta(mid210, 31)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid210, 28)), + i.Lookup(kw(u"node"), meta=i.Meta(mid210, 40)), + ], + meta=i.Meta(mid210, 13)), + ], + meta=i.Meta(mid209, 5)), + meta=i.Meta(mid207, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/EMPTY) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid211, 13)), + i.Const(rt.wrap(0)), + i.Const(rt.wrap(5)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid211, 36)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid211, 48)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid211, 47)), + i.Const(nil), + ], + meta=i.Meta(mid211, 12))]), + i.Invoke(args=[ +# (def pixie.stdlib/vector-from-array) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"vector-from-array")), + i.Fn(args=[kw(u"arr")],name=kw(u"vector-from-array"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid212, 8)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid212, 11)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid212, 17)), + ], + meta=i.Meta(mid212, 10)), + i.Const(rt.wrap(32)), + ], + meta=i.Meta(mid212, 7)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid213, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid213, 26)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid213, 32)), + ], + meta=i.Meta(mid213, 25)), + i.Const(rt.wrap(5)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid213, 39)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid213, 50)), + i.Const(nil), + ], + meta=i.Meta(mid213, 5)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid214, 6)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), + i.Lookup(kw(u"arr"), meta=i.Meta(mid214, 14)), + ], + meta=i.Meta(mid214, 5)), + meta=i.Meta(mid212, 3)), + )]), + i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid215, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid216, 14)), + i.Fn(args=[kw(u"this"),kw(u"f"),kw(u"init")],name=kw(u"fn_528"), + body=i.Let(names=[kw(u"idx"),kw(u"acc")], + bindings=[ + i.Const(rt.wrap(0)), + i.Lookup(kw(u"init"), meta=i.Meta(mid217, 16)), + ], + body=i.TailCall( + args=[ + i.Fn(args=[kw(u"idx"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"this"),kw(u"f")], + body=i.Let(names=[kw(u"idx"),kw(u"acc")], + bindings=[ + i.Lookup(kw(u"idx"), meta=i.Meta(mid218, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid217, 12)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid219, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid219, 21)), + ], + meta=i.Meta(mid219, 11)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), + i.Lookup(kw(u"acc"), meta=i.Meta(mid220, 10)), + ], + meta=i.Meta(mid220, 9)), + els=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid221, 14)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid221, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid221, 21)), + i.Lookup(kw(u"this"), meta=i.Meta(mid221, 27)), + ], + meta=i.Meta(mid221, 20)), + ], + meta=i.Meta(mid221, 13)), + then=i.TailCall( + args=[ + i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid222, 19)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid222, 23)), + ], + meta=i.Meta(mid222, 18)), + i.Invoke( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid223, 19)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid223, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid223, 26)), + i.Lookup(kw(u"this"), meta=i.Meta(mid223, 31)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid223, 36)), + ], + meta=i.Meta(mid223, 25)), + ], + meta=i.Meta(mid223, 18)), + ], + meta=nil), + els=i.Lookup(kw(u"acc"), meta=i.Meta(mid224, 11)), + meta=i.Meta(mid221, 9)), + meta=i.Meta(mid219, 7)), + meta=nil), + ), + i.Lookup(kw(u"idx"), meta=i.Meta(mid218, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid217, 12)), + ], + meta=nil), + meta=i.Meta(mid218, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid225, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid216, 14)), + i.Fn(args=[kw(u"arr")],name=kw(u"fn_532"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Lookup(kw(u"arr"), meta=i.Meta(mid226, 21)), + i.Const(kw(u"count")), + ], + meta=i.Meta(mid226, 12)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid227, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid216, 14)), + i.Fn(args=[kw(u"arr"),kw(u"itm")],name=kw(u"fn_524"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid228, 12)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"vector-from-array"), meta=i.Meta(mid228, 18)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid228, 36)), + ], + meta=i.Meta(mid228, 17)), + i.Lookup(kw(u"itm"), meta=i.Meta(mid228, 41)), + ], + meta=i.Meta(mid228, 11)), + ), + ], + meta=nil), + ], + meta=i.Meta(mid216, 1)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid229, 2)), + i.Const(rt.wrap(42)), + ], + meta=i.Meta(mid229, 1)), + i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid230, 2)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid230, 11)), + i.Const(rt.wrap(1000)), + ], + meta=i.Meta(mid230, 10)), + ], + meta=i.Meta(mid230, 1)), + ], +meta=i.Meta(mid231, 1)) \ No newline at end of file diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index e32a58d8..ec76afbb 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -92,13 +92,19 @@ (-invoke-method [this name args])) + (extend -get-field Object -internal-get-field) (extend -str Object (fn [x sb] - (sb (-internal-tostr x)))) + (sb (-internal-to-str x)))) (extend -repr Object (fn [x sb] (sb (-internal-to-repr x)))) +(extend-type String + IObject + (-str [this sb] + (sb this))) + ;; Math wrappers (extend -eq Number -num-eq) @@ -192,7 +198,18 @@ args)) (defn println [& args] - (-blocking-println (-apply str args))) + (let [sb (-string-builder) + add-fn (fn [x] + (-add-to-string-builder sb x))] + (loop [idx 0 + sb sb] + (if (< idx (count args)) + (recur (inc idx) + (do (-str (aget args idx) add-fn) + (add-fn " ") + sb)) + (-blocking-println (-finish-string-builder sb)))) + nil)) ;; @@ -503,6 +520,7 @@ ;;; +(println 42) (into [] (range 1000)) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 6f0bb380..4bb19b9f 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -732,4 +732,4 @@ (let [form (read-string (str "(do " (pixie.io/slurp "pixie/bootstrap.pxi") ")")) str (finish-context (to-rpython (writer-context) 0 (collect-closed-overs (clean-do (analyze form)))))] (print str) - (io/spit "/tmp/pxi.py" str)) + (io/spit "./bootstrap.py" str)) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 6ddbe5c5..614c4a01 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -1,4 +1,4 @@ -from pixie.vm2.object import Object, Type, Continuation, stack_cons +from pixie.vm2.object import Object, Type, Continuation, stack_cons, runtime_error from pixie.vm2.primitives import nil, false from pixie.vm2.array import Array import pixie.vm2.code as code @@ -142,7 +142,12 @@ def invoke_k_with(self, args, stack, self_fn): # TODO: Check arg count locals = jit.promote(self._c_locals) locals = Locals(jit.promote(self._c_name), self_fn, locals) + arg_names = jit.promote(self._c_arg_names) + if not len(args) == len(arg_names): + runtime_error(u"Wrong number args, expected " + unicode(str(len(args))) + u" got " + unicode(str(len(arg_names))), + u"pixie.stdlib.ArityException") + for idx in range(len(arg_names)): locals = Locals(arg_names[idx], args[idx], locals) diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index 6b52da29..c8f030cc 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -1,4 +1,5 @@ import rpython.rlib.jit as jit +from rpython.rlib.objectmodel import we_are_translated class Object(object): """ Base Object for all VM objects @@ -166,7 +167,9 @@ def run_stack(val, cont, stack=None): val, stack = cont.call_continuation(val, stack) except BaseException as ex: print_stacktrace(cont, stack) - #print ex + if not we_are_translated(): + print ex + raise break if stack is None: return val @@ -213,5 +216,6 @@ def __init__(self, ex): self._ex = ex def runtime_error(msg, kw=None): + print msg raise WrappedException(RuntimeException(msg, kw)) diff --git a/target2.py b/target2.py index ec718623..e1a075fb 100644 --- a/target2.py +++ b/target2.py @@ -10,7 +10,7 @@ rt.init() -with open("/tmp/pxi.py") as f: +with open("bootstrap.py") as f: exec f.read() pixie_code = code_ast From 6604f8a6d72eb247010fb135b4007854f5e633f3 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sat, 16 May 2015 16:37:53 -0600 Subject: [PATCH 10/46] fixed a nasty bug with local macros --- Makefile | 4 +- bootstrap.py | 1631 +++++++++++++++++++++++++++---------------- pixie/bootstrap.pxi | 37 +- pixie/compiler.pxi | 19 +- target2.py | 2 +- 5 files changed, 1090 insertions(+), 603 deletions(-) diff --git a/Makefile b/Makefile index 0add034a..1b9bf44b 100644 --- a/Makefile +++ b/Makefile @@ -95,6 +95,6 @@ clean: clean_pxic rm -f ./*.pyc compile_rpython: - touch /tmp/pxi.py - rm /tmp/pxi.py + touch ./bootstrap.py + rm ./bootstrap.py ./pixie-vm pixie/compiler.pxi diff --git a/bootstrap.py b/bootstrap.py index ee122a38..98143394 100755 --- a/bootstrap.py +++ b/bootstrap.py @@ -129,107 +129,131 @@ mid128 = (u""" acc init]""", "", 338) mid129 = (u""" (loop [i start""", "", 337) mid130 = (u""" (println i)""", "", 339) -mid131 = (u""" (if (or (and (> step 0) (< i stop))""", "", 340) -mid132 = (u""" (and (< step 0) (> i stop))""", "", 341) -mid133 = (u""" (and (= step 0)))""", "", 342) -mid134 = (u""" (let [acc (f acc i)]""", "", 343) -mid135 = (u""" (if (reduced? acc)""", "", 344) -mid136 = (u""" @acc""", "", 345) -mid137 = (u""" (recur (+ i step) acc)))""", "", 346) -mid138 = (u""" acc)))""", "", 347) -mid139 = (u""" (-count [self]""", "", 349) -mid140 = (u""" (if (or (and (< start stop) (< step 0))""", "", 350) -mid141 = (u""" (and (> start stop) (> step 0))""", "", 351) -mid142 = (u""" (= step 0))""", "", 352) -mid143 = (u""" (abs (quot (- start stop) step))))""", "", 354) -mid144 = (u""" (-nth [self idx]""", "", 356) -mid145 = (u""" (when (or (= start stop 0) (neg? idx))""", "", 357) -mid146 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))""", "", 358) -mid147 = (u""" (-nth-not-found [self idx not-found]""", "", 364) -mid148 = (u""" (let [cmp (if (< start stop) < >)""", "", 365) -mid149 = (u""" val (+ start (* idx step))]""", "", 366) -mid150 = (u""" (if (cmp val stop)""", "", 367) -mid151 = (u""" val""", "", 368) -mid152 = (u""" not-found)))""", "", 369) -mid153 = (u""" (-seq [self]""", "", 371) -mid154 = (u""" (when (or (and (> step 0) (< start stop))""", "", 372) -mid155 = (u""" (and (< step 0) (> start stop)))""", "", 373) -mid156 = (u""" (cons start (lazy-seq* #(range (+ start step) stop step)))))""", "", 374) -mid157 = (u""" (-str [this sbf]""", "", 376) -mid158 = (u""" (-str (seq this) sbf))""", "", 377) -mid159 = (u""" (-repr [this sbf]""", "", 378) -mid160 = (u""" (-repr (seq this) sbf))""", "", 379) -mid161 = (u""" (-eq [this sb]))""", "", 380) -mid162 = (u""" ([] (->Range 0 MAX-NUMBER 1))""", "", 392) -mid163 = (u""" ([stop] (->Range 0 stop 1))""", "", 393) -mid164 = (u""" ([start stop step] (->Range start stop step)))""", "", 395) -mid165 = (u""" ([start stop] (->Range start stop 1))""", "", 394) -mid166 = (u"""(deftype Node [edit array]""", "", 401) -mid167 = (u""" (-get-field [this name]""", "", 403) -mid168 = (u""" (get-field this name)))""", "", 404) -mid169 = (u""" (new-node edit (array 32)))""", "", 408) -mid170 = (u""" (->Node edit array)))""", "", 410) -mid171 = (u"""(def EMPTY-NODE (new-node nil))""", "", 412) -mid172 = (u""" (let [cnt (.-cnt this)]""", "", 417) -mid173 = (u""" (if (< cnt 32)""", "", 418) -mid174 = (u""" (bit-shift-left (bit-shift-right (dec cnt) 5) 5))))""", "", 420) -mid175 = (u""" (if (and (<= 0 i) (< i cnt))""", "", 423) -mid176 = (u""" (if (>= i (tailoff this))""", "", 424) -mid177 = (u""" tail""", "", 425) -mid178 = (u""" (if (> level 0)""", "", 427) -mid179 = (u""" (look-deeper (aget (:array node)""", "", 428) -mid180 = (u""" (bit-and (bit-shift-right i level) 0x01f))""", "", 429) -mid181 = (u""" (- level 5))""", "", 430) -mid182 = (u""" (:array node)))""", "", 431) -mid183 = (u""" root""", "", 432) -mid184 = (u""" shift)))))""", "", 433) -mid185 = (u""" (.-array ((fn look-deeper [node level]""", "", 426) -mid186 = (u"""(deftype PersistentVector [cnt shift root tail meta]""", "", 435) -mid187 = (u""" (-get-field [this name]""", "", 437) -mid188 = (u""" (get-field this name))""", "", 438) -mid189 = (u""" (-conj [this val]""", "", 441) -mid190 = (u""" (assert (< cnt 0xFFFFFFFF) "Vector too large")""", "", 442) -mid191 = (u""" (-count [this] cnt))""", "", 465) -mid192 = (u""" (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f)""", "", 469) -mid193 = (u""" ret-array (aclone (.-array parent))""", "", 470) -mid194 = (u""" node-to-insert (if (= level 5)""", "", 471) -mid195 = (u""" tail-node""", "", 472) -mid196 = (u""" (let [child (aget (.-array parent) subidx)]""", "", 473) -mid197 = (u""" (if (= child nil)""", "", 474) -mid198 = (u""" (new-path (.-edit (.-root this))""", "", 475) -mid199 = (u""" (- level 5)""", "", 476) -mid200 = (u""" tail-node)""", "", 477) -mid201 = (u""" (push-tail this""", "", 478) -mid202 = (u""" (- level 5)""", "", 479) -mid203 = (u""" child""", "", 480) -mid204 = (u""" tail-node))))]""", "", 481) -mid205 = (u""" (aset ret-array subidx node-to-insert)""", "", 482) -mid206 = (u""" (->Node (.-edit parent) node-to-insert)))""", "", 483) -mid207 = (u""" (if (= level 0)""", "", 486) -mid208 = (u""" node""", "", 487) -mid209 = (u""" (->Node edit""", "", 488) -mid210 = (u""" (new-path edit (- level 5) node))))""", "", 489) -mid211 = (u"""(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil))""", "", 492) -mid212 = (u""" (if (< (count arr) 32)""", "", 495) -mid213 = (u""" (->PersistentVector (count arr) 5 EMPTY-NODE arr nil)""", "", 496) -mid214 = (u""" (into [] arr)))""", "", 497) -mid215 = (u""" (-reduce [this f init]""", "", 510) -mid216 = (u"""(extend-type Array""", "", 501) -mid217 = (u""" acc init]""", "", 512) -mid218 = (u""" (loop [idx 0""", "", 511) -mid219 = (u""" (if (reduced? acc)""", "", 513) -mid220 = (u""" @acc""", "", 514) -mid221 = (u""" (if (< idx (count this))""", "", 515) -mid222 = (u""" (recur (inc idx)""", "", 516) -mid223 = (u""" (f acc (aget this idx)))""", "", 517) -mid224 = (u""" acc)))))""", "", 518) -mid225 = (u""" (-count ([arr]""", "", 506) -mid226 = (u""" (.-count arr)))""", "", 507) -mid227 = (u""" (-conj ([arr itm]""", "", 503) -mid228 = (u""" (conj (vector-from-array arr) itm)))""", "", 504) -mid229 = (u"""(println 42)""", "", 523) -mid230 = (u"""(into [] (range 1000))""", "", 525) -mid231 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) +mid131 = (u""" (println acc)""", "", 340) +mid132 = (u""" (if (or (and (> step 0) (< i stop))""", "", 341) +mid133 = (u""" (and (< step 0) (> i stop))""", "", 342) +mid134 = (u""" (and (= step 0)))""", "", 343) +mid135 = (u""" (let [acc (f acc i)]""", "", 344) +mid136 = (u""" (if (reduced? acc)""", "", 345) +mid137 = (u""" @acc""", "", 346) +mid138 = (u""" (recur (+ i step) acc)))""", "", 347) +mid139 = (u""" acc)))""", "", 348) +mid140 = (u""" (-count [self]""", "", 350) +mid141 = (u""" (if (or (and (< start stop) (< step 0))""", "", 351) +mid142 = (u""" (and (> start stop) (> step 0))""", "", 352) +mid143 = (u""" (= step 0))""", "", 353) +mid144 = (u""" (abs (quot (- start stop) step))))""", "", 355) +mid145 = (u""" (-nth [self idx]""", "", 357) +mid146 = (u""" (when (or (= start stop 0) (neg? idx))""", "", 358) +mid147 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))""", "", 359) +mid148 = (u""" (let [cmp (if (< start stop) < >)""", "", 360) +mid149 = (u""" val (+ start (* idx step))]""", "", 361) +mid150 = (u""" (if (cmp val stop)""", "", 362) +mid151 = (u""" val""", "", 363) +mid152 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))))""", "", 364) +mid153 = (u""" (-nth-not-found [self idx not-found]""", "", 365) +mid154 = (u""" (let [cmp (if (< start stop) < >)""", "", 366) +mid155 = (u""" val (+ start (* idx step))]""", "", 367) +mid156 = (u""" (if (cmp val stop)""", "", 368) +mid157 = (u""" val""", "", 369) +mid158 = (u""" not-found)))""", "", 370) +mid159 = (u""" (-seq [self]""", "", 372) +mid160 = (u""" (when (or (and (> step 0) (< start stop))""", "", 373) +mid161 = (u""" (and (< step 0) (> start stop)))""", "", 374) +mid162 = (u""" (cons start (lazy-seq* #(range (+ start step) stop step)))))""", "", 375) +mid163 = (u""" (-str [this sbf]""", "", 377) +mid164 = (u""" (-str (seq this) sbf))""", "", 378) +mid165 = (u""" (-repr [this sbf]""", "", 379) +mid166 = (u""" (-repr (seq this) sbf))""", "", 380) +mid167 = (u""" (-eq [this sb]))""", "", 381) +mid168 = (u""" (analyze-form (cons 'do body))))""", "pixie/compiler.pxi", 259) +mid169 = (u""" ([] (->Range 0 MAX-NUMBER 1))""", "", 393) +mid170 = (u""" ([stop] (->Range 0 stop 1))""", "", 394) +mid171 = (u""" ([start stop step] (->Range start stop step)))""", "", 396) +mid172 = (u""" ([start stop] (->Range start stop 1))""", "", 395) +mid173 = (u"""(deftype Node [edit array]""", "", 402) +mid174 = (u""" (-get-field [this name]""", "", 404) +mid175 = (u""" (get-field this name)))""", "", 405) +mid176 = (u""" (new-node edit (array 32)))""", "", 409) +mid177 = (u""" (->Node edit array)))""", "", 411) +mid178 = (u"""(def EMPTY-NODE (new-node nil))""", "", 413) +mid179 = (u""" (let [cnt (.-cnt this)]""", "", 418) +mid180 = (u""" (if (< cnt 32)""", "", 419) +mid181 = (u""" (bit-shift-left (bit-shift-right (dec cnt) 5) 5))))""", "", 421) +mid182 = (u""" (if (and (<= 0 i) (< i cnt))""", "", 424) +mid183 = (u""" (if (>= i (tailoff this))""", "", 425) +mid184 = (u""" tail""", "", 426) +mid185 = (u""" (if (> level 0)""", "", 428) +mid186 = (u""" (look-deeper (aget (:array node)""", "", 429) +mid187 = (u""" (bit-and (bit-shift-right i level) 0x01f))""", "", 430) +mid188 = (u""" (- level 5))""", "", 431) +mid189 = (u""" (:array node)))""", "", 432) +mid190 = (u""" root""", "", 433) +mid191 = (u""" shift)))))""", "", 434) +mid192 = (u""" (.-array ((fn look-deeper [node level]""", "", 427) +mid193 = (u"""(deftype PersistentVector [cnt shift root tail meta]""", "", 436) +mid194 = (u""" (-get-field [this name]""", "", 438) +mid195 = (u""" (get-field this name))""", "", 439) +mid196 = (u""" (-conj [this val]""", "", 442) +mid197 = (u""" (assert (< cnt 0xFFFFFFFF) "Vector too large")""", "", 443) +mid198 = (u""" (if (< (- cnt (tailoff this)) 32)""", "", 445) +mid199 = (u""" (let [new-tail (array-append tail val)]""", "", 446) +mid200 = (u""" (->PersistentVector (inc cnt) shift root new-tail meta))""", "", 447) +mid201 = (u""" (let [tail-node (->Node (.-edit root) tail)]""", "", 449) +mid202 = (u""" (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift))""", "", 450) +mid203 = (u""" (let [new-root (new-node (.-edit root))]""", "", 452) +mid204 = (u""" (aset new-root 0 root)""", "", 453) +mid205 = (u""" (aset new-root 1 (new-path (.-edit root) shift tail-node))""", "", 454) +mid206 = (u""" (->PersistentVector (inc cnt)""", "", 455) +mid207 = (u""" (+ shift 5)""", "", 456) +mid208 = (u""" new-root""", "", 457) +mid209 = (u""" (array val)""", "", 458) +mid210 = (u""" (let [new-root (push-tail this shift root tail-node)]""", "", 460) +mid211 = (u""" (->PersistentVector (inc cnt)""", "", 461) +mid212 = (u""" new-root""", "", 463) +mid213 = (u""" (array val)""", "", 464) +mid214 = (u""" (-count [this] cnt))""", "", 468) +mid215 = (u""" (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f)""", "", 472) +mid216 = (u""" ret-array (aclone (.-array parent))""", "", 473) +mid217 = (u""" node-to-insert (if (= level 5)""", "", 474) +mid218 = (u""" tail-node""", "", 475) +mid219 = (u""" (let [child (aget (.-array parent) subidx)]""", "", 476) +mid220 = (u""" (if (= child nil)""", "", 477) +mid221 = (u""" (new-path (.-edit (.-root this))""", "", 478) +mid222 = (u""" (- level 5)""", "", 479) +mid223 = (u""" tail-node)""", "", 480) +mid224 = (u""" (push-tail this""", "", 481) +mid225 = (u""" (- level 5)""", "", 482) +mid226 = (u""" child""", "", 483) +mid227 = (u""" tail-node))))]""", "", 484) +mid228 = (u""" (aset ret-array subidx node-to-insert)""", "", 485) +mid229 = (u""" (->Node (.-edit parent) node-to-insert)))""", "", 486) +mid230 = (u""" (if (= level 0)""", "", 489) +mid231 = (u""" node""", "", 490) +mid232 = (u""" (->Node edit""", "", 491) +mid233 = (u""" (new-path edit (- level 5) node))))""", "", 492) +mid234 = (u"""(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil))""", "", 495) +mid235 = (u""" (println "Vector for array")""", "", 498) +mid236 = (u""" (println (count arr))""", "", 499) +mid237 = (u""" (if (< (count arr) 32)""", "", 500) +mid238 = (u""" (->PersistentVector (count arr) 5 EMPTY-NODE arr nil)""", "", 501) +mid239 = (u""" (into [] arr)))""", "", 502) +mid240 = (u""" (-reduce [this f init]""", "", 516) +mid241 = (u"""(extend-type Array""", "", 506) +mid242 = (u""" acc init]""", "", 518) +mid243 = (u""" (loop [idx 0""", "", 517) +mid244 = (u""" (if (reduced? acc)""", "", 519) +mid245 = (u""" @acc""", "", 520) +mid246 = (u""" (if (< idx (count this))""", "", 521) +mid247 = (u""" (recur (inc idx)""", "", 522) +mid248 = (u""" (f acc (aget this idx)))""", "", 523) +mid249 = (u""" acc)))))""", "", 524) +mid250 = (u""" (-count ([arr]""", "", 512) +mid251 = (u""" (.-count arr)))""", "", 513) +mid252 = (u""" (-conj [arr itm]""", "", 508) +mid253 = (u""" (conj (vector-from-array arr) itm))""", "", 509) +mid254 = (u"""(into [] (range 4))""", "", 529) +mid255 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) code_ast=i.Do( @@ -1020,7 +1044,7 @@ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid25, 2)), i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid25, 9)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid25, 14)), - i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_348"), + i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_353"), body=i.TailCall( args=[ i.Lookup(kw(u"sb"), meta=i.Meta(mid26, 24)), @@ -1040,7 +1064,7 @@ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid27, 2)), i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid27, 9)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid27, 15)), - i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_351"), + i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_356"), body=i.TailCall( args=[ i.Lookup(kw(u"sb"), meta=i.Meta(mid28, 25)), @@ -1060,7 +1084,7 @@ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid29, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid30, 14)), - i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"fn_354"), + i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"fn_359"), body=i.TailCall( args=[ i.Lookup(kw(u"sb"), meta=i.Meta(mid31, 6)), @@ -1254,7 +1278,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"=")), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"=")), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"="), - body=i.Const(nil), + body=i.Const(true), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"="), body=i.If( @@ -1265,7 +1289,7 @@ i.Lookup(kw(u"y"), meta=i.Meta(mid45, 28)), ], meta=i.Meta(mid45, 14)), - then=i.Const(nil), + then=i.Const(true), els=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid46, 13)), @@ -1572,7 +1596,7 @@ i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid70, 13)), ], meta=i.Meta(mid70, 12)), - i.Fn(args=[kw(u"x")],name=kw(u"fn_410"),closed_overs=[kw(u"sb")], + i.Fn(args=[kw(u"x")],name=kw(u"fn_415"),closed_overs=[kw(u"sb")], body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid71, 19)), @@ -1712,7 +1736,7 @@ i.Lookup(kw(u"x"), meta=i.Meta(mid83, 38)), ], meta=i.Meta(mid83, 15)), - then=i.Const(nil), + then=i.Const(true), els=i.TailCall( args=[ i.Lookup(kw(u"instance?"), meta=i.Meta(mid84, 14)), @@ -1837,7 +1861,7 @@ i.Lookup(kw(u"ps"), meta=i.Meta(mid92, 16)), ], meta=i.Meta(mid92, 11)), - then=i.Const(nil), + then=i.Const(true), els=i.If( test=i.Invoke( args=[ @@ -2080,16 +2104,16 @@ i.Const(code.intern_var(u"pixie.stdlib",u"map")), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"map")), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"f")],name=kw(u"map"), - body=i.Fn(args=[kw(u"xf")],name=kw(u"fn_447"),closed_overs=[kw(u"f")], - body=i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"fn_451")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"fn_451"),closed_overs=[kw(u"xf")], + body=i.Fn(args=[kw(u"xf")],name=kw(u"fn_452"),closed_overs=[kw(u"f")], + body=i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"fn_456")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"fn_456"),closed_overs=[kw(u"xf")], body=i.TailCall( args=[ i.Lookup(kw(u"xf"), meta=i.Meta(mid112, 13)), ], meta=i.Meta(mid112, 12)), ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"result")],name=kw(u"fn_451"),closed_overs=[kw(u"xf")], + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"result")],name=kw(u"fn_456"),closed_overs=[kw(u"xf")], body=i.TailCall( args=[ i.Lookup(kw(u"xf"), meta=i.Meta(mid113, 19)), @@ -2097,7 +2121,7 @@ ], meta=i.Meta(mid113, 18)), ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"result"),kw(u"item")],name=kw(u"fn_451"),closed_overs=[kw(u"xf"),kw(u"f")], + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"result"),kw(u"item")],name=kw(u"fn_456"),closed_overs=[kw(u"xf"),kw(u"f")], body=i.TailCall( args=[ i.Lookup(kw(u"xf"), meta=i.Meta(mid114, 24)), @@ -2118,7 +2142,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid115, 5)), - i.Fn(args=[],name=kw(u"fn_452"),closed_overs=[kw(u"map"),kw(u"f"),kw(u"coll")], + i.Fn(args=[],name=kw(u"fn_457"),closed_overs=[kw(u"map"),kw(u"f"),kw(u"coll")], body=i.Let(names=[kw(u"s")], bindings=[ i.Invoke( @@ -2174,7 +2198,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid120, 18)), - i.Fn(args=[],name=kw(u"fn_454"),closed_overs=[kw(u"step"),kw(u"map"),kw(u"cs")], + i.Fn(args=[],name=kw(u"fn_459"),closed_overs=[kw(u"step"),kw(u"map"),kw(u"cs")], body=i.Let(names=[kw(u"ss")], bindings=[ i.Invoke( @@ -2228,7 +2252,7 @@ body=i.TailCall( args=[ i.Lookup(kw(u"map"), meta=i.Meta(mid124, 7)), - i.Fn(args=[kw(u"args")],name=kw(u"fn_456"),closed_overs=[kw(u"f")], + i.Fn(args=[kw(u"args")],name=kw(u"fn_461"),closed_overs=[kw(u"f")], body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid124, 23)), @@ -2313,13 +2337,19 @@ i.Lookup(kw(u"i"), meta=i.Meta(mid130, 16)), ], meta=i.Meta(mid130, 7)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid131, 8)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid131, 16)), + ], + meta=i.Meta(mid131, 7)), i.If( test=i.Let(names=[kw(u"r#__gensym_321")], bindings=[ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid131, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid132, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), @@ -2329,11 +2359,11 @@ meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid131, 20)), + meta=i.Meta(mid132, 20)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid131, 32)), - i.Lookup(kw(u"i"), meta=i.Meta(mid131, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid132, 32)), + i.Lookup(kw(u"i"), meta=i.Meta(mid132, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), @@ -2342,9 +2372,9 @@ ], meta=nil), ], - meta=i.Meta(mid131, 31)), + meta=i.Meta(mid132, 31)), els=i.Const(nil), - meta=i.Meta(mid131, 15)), + meta=i.Meta(mid132, 15)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), @@ -2354,7 +2384,7 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid132, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid133, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), @@ -2364,11 +2394,11 @@ meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid132, 20)), + meta=i.Meta(mid133, 20)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid132, 32)), - i.Lookup(kw(u"i"), meta=i.Meta(mid132, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid133, 32)), + i.Lookup(kw(u"i"), meta=i.Meta(mid133, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), @@ -2377,16 +2407,16 @@ ], meta=nil), ], - meta=i.Meta(mid132, 31)), + meta=i.Meta(mid133, 31)), els=i.Const(nil), - meta=i.Meta(mid132, 15)), + meta=i.Meta(mid133, 15)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), els=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid133, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid134, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), @@ -2396,41 +2426,41 @@ meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid133, 15)), + meta=i.Meta(mid134, 15)), meta=nil), meta=nil), meta=nil), - meta=i.Meta(mid131, 11)), + meta=i.Meta(mid132, 11)), then=i.Let(names=[kw(u"acc")], bindings=[ i.Invoke( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid134, 20)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid134, 22)), - i.Lookup(kw(u"i"), meta=i.Meta(mid134, 26)), + i.Lookup(kw(u"f"), meta=i.Meta(mid135, 20)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid135, 22)), + i.Lookup(kw(u"i"), meta=i.Meta(mid135, 26)), ], - meta=i.Meta(mid134, 19)), + meta=i.Meta(mid135, 19)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid135, 16)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid135, 25)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid136, 16)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid136, 25)), ], - meta=i.Meta(mid135, 15)), + meta=i.Meta(mid136, 15)), then=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), - i.Lookup(kw(u"acc"), meta=i.Meta(mid136, 14)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid137, 14)), ], - meta=i.Meta(mid136, 13)), + meta=i.Meta(mid137, 13)), els=i.TailCall( args=[ i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid137, 21)), - i.Lookup(kw(u"i"), meta=i.Meta(mid137, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid138, 21)), + i.Lookup(kw(u"i"), meta=i.Meta(mid138, 23)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), @@ -2439,14 +2469,14 @@ ], meta=nil), ], - meta=i.Meta(mid137, 20)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid137, 31)), + meta=i.Meta(mid138, 20)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid138, 31)), ], meta=nil), - meta=i.Meta(mid135, 11)), - meta=i.Meta(mid134, 9)), - els=i.Lookup(kw(u"acc"), meta=i.Meta(mid138, 9)), - meta=i.Meta(mid131, 7)), + meta=i.Meta(mid136, 11)), + meta=i.Meta(mid135, 9)), + els=i.Lookup(kw(u"acc"), meta=i.Meta(mid139, 9)), + meta=i.Meta(mid132, 7)), ], meta=nil), meta=nil), @@ -2462,7 +2492,7 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid139, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid140, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), i.Fn(args=[kw(u"self")],name=kw(u"-count_Range"), body=i.If( @@ -2471,38 +2501,38 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid140, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid141, 19)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid140, 18)), + meta=i.Meta(mid141, 18)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid140, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid141, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid140, 33)), + meta=i.Meta(mid141, 33)), els=i.Const(nil), - meta=i.Meta(mid140, 13)), + meta=i.Meta(mid141, 13)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), @@ -2512,159 +2542,240 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid141, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid142, 19)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid141, 18)), + meta=i.Meta(mid142, 18)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid141, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid142, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid141, 33)), + meta=i.Meta(mid142, 33)), els=i.Const(nil), - meta=i.Meta(mid141, 13)), + meta=i.Meta(mid142, 13)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), els=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid142, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid143, 14)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid142, 13)), + meta=i.Meta(mid143, 13)), meta=nil), meta=nil), meta=nil), - meta=i.Meta(mid140, 9)), + meta=i.Meta(mid141, 9)), then=i.Const(rt.wrap(0)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"abs"), meta=i.Meta(mid143, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"abs"), meta=i.Meta(mid144, 8)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"quot"), meta=i.Meta(mid143, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"quot"), meta=i.Meta(mid144, 13)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid143, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid144, 19)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid143, 18)), + meta=i.Meta(mid144, 18)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid143, 12)), + meta=i.Meta(mid144, 12)), ], - meta=i.Meta(mid143, 7)), - meta=i.Meta(mid140, 5)), + meta=i.Meta(mid144, 7)), + meta=i.Meta(mid141, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid144, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid145, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), i.Fn(args=[kw(u"self"),kw(u"idx")],name=kw(u"-nth_Range"), - body=i.If( - test=i.Let(names=[kw(u"r#__gensym_320")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid145, 16)), + body=i.Do( + args=[ + i.If( + test=i.Let(names=[kw(u"r#__gensym_320")], + bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid144, 10)), - i.Const(kw(u"start")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid146, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Const(kw(u"stop")), + ], + meta=nil), + i.Const(rt.wrap(0)), ], + meta=i.Meta(mid146, 15)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"neg?"), meta=i.Meta(mid146, 33)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid146, 38)), + ], + meta=i.Meta(mid146, 32)), meta=nil), - i.Invoke( + meta=i.Meta(mid146, 11)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid147, 8)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), + i.Const(rt.wrap(u"Index out of Range")), + ]), + ], + meta=i.Meta(mid147, 7)), + els=i.Const(nil), + meta=i.Meta(mid146, 5)), + i.Let(names=[kw(u"cmp"),kw(u"val")], + bindings=[ + i.If( + test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid144, 10)), - i.Const(kw(u"stop")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Const(kw(u"stop")), + ], + meta=nil), ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid145, 15)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - els=i.Invoke( + meta=i.Meta(mid148, 19)), + then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 34)), + els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid148, 36)), + meta=i.Meta(mid148, 15)), + i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"neg?"), meta=i.Meta(mid145, 33)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid145, 38)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid149, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Const(kw(u"start")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid149, 25)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid149, 27)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Const(kw(u"step")), + ], + meta=nil), + ], + meta=i.Meta(mid149, 24)), ], - meta=i.Meta(mid145, 32)), - meta=nil), - meta=i.Meta(mid145, 11)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid146, 8)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), - i.Const(rt.wrap(u"Index out of Range")), - ]), - ], - meta=i.Meta(mid146, 7)), - els=i.Const(nil), - meta=i.Meta(mid145, 5)), + meta=i.Meta(mid149, 15)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.Lookup(kw(u"cmp"), meta=i.Meta(mid150, 12)), + i.Lookup(kw(u"val"), meta=i.Meta(mid150, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid150, 11)), + then=i.Lookup(kw(u"val"), meta=i.Meta(mid151, 9)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid152, 10)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), + i.Const(rt.wrap(u"Index out of Range")), + ]), + ], + meta=i.Meta(mid152, 9)), + meta=i.Meta(mid150, 7)), + meta=i.Meta(mid148, 5)), + ], + meta=nil), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid147, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid153, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), i.Fn(args=[kw(u"self"),kw(u"idx"),kw(u"not-found")],name=kw(u"-nth-not-found_Range"), body=i.Let(names=[kw(u"cmp"),kw(u"val")], @@ -2672,77 +2783,77 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid154, 20)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid148, 19)), - then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 34)), - els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid148, 36)), - meta=i.Meta(mid148, 15)), + meta=i.Meta(mid154, 19)), + then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid154, 34)), + els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid154, 36)), + meta=i.Meta(mid154, 15)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid149, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid155, 16)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid149, 25)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid149, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid155, 25)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid155, 27)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid149, 24)), + meta=i.Meta(mid155, 24)), ], - meta=i.Meta(mid149, 15)), + meta=i.Meta(mid155, 15)), ], body=i.If( test=i.Invoke( args=[ - i.Lookup(kw(u"cmp"), meta=i.Meta(mid150, 12)), - i.Lookup(kw(u"val"), meta=i.Meta(mid150, 16)), + i.Lookup(kw(u"cmp"), meta=i.Meta(mid156, 12)), + i.Lookup(kw(u"val"), meta=i.Meta(mid156, 16)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid147, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid150, 11)), - then=i.Lookup(kw(u"val"), meta=i.Meta(mid151, 9)), - els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid152, 8)), - meta=i.Meta(mid150, 7)), - meta=i.Meta(mid148, 5)), + meta=i.Meta(mid156, 11)), + then=i.Lookup(kw(u"val"), meta=i.Meta(mid157, 9)), + els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid158, 8)), + meta=i.Meta(mid156, 7)), + meta=i.Meta(mid154, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid153, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid159, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), i.Fn(args=[kw(u"self")],name=kw(u"-seq_Range"), body=i.If( @@ -2751,38 +2862,38 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid154, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid160, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid154, 20)), + meta=i.Meta(mid160, 20)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid154, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid160, 32)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid154, 31)), + meta=i.Meta(mid160, 31)), els=i.Const(nil), - meta=i.Meta(mid154, 15)), + meta=i.Meta(mid160, 15)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), @@ -2790,151 +2901,151 @@ els=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid155, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid161, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid155, 20)), + meta=i.Meta(mid161, 20)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid155, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid161, 32)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid155, 31)), + meta=i.Meta(mid161, 31)), els=i.Const(nil), - meta=i.Meta(mid155, 15)), + meta=i.Meta(mid161, 15)), meta=nil), - meta=i.Meta(mid154, 11)), + meta=i.Meta(mid160, 11)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid156, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid162, 8)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid156, 20)), - i.Fn(args=[],name=kw(u"fn_475"),closed_overs=[kw(u"self")], + i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid162, 20)), + i.Fn(args=[],name=kw(u"fn_480"),closed_overs=[kw(u"self")], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid156, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid162, 32)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid156, 39)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid162, 39)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid156, 38)), + meta=i.Meta(mid162, 38)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"stop")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid156, 31)), + meta=i.Meta(mid162, 31)), ), ], - meta=i.Meta(mid156, 19)), + meta=i.Meta(mid162, 19)), ], - meta=i.Meta(mid156, 7)), + meta=i.Meta(mid162, 7)), els=i.Const(nil), - meta=i.Meta(mid154, 5)), + meta=i.Meta(mid160, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid157, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid163, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-str_Range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid158, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid164, 6)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid158, 12)), - i.Lookup(kw(u"this"), meta=i.Meta(mid158, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid164, 12)), + i.Lookup(kw(u"this"), meta=i.Meta(mid164, 16)), ], - meta=i.Meta(mid158, 11)), - i.Lookup(kw(u"sbf"), meta=i.Meta(mid158, 22)), + meta=i.Meta(mid164, 11)), + i.Lookup(kw(u"sbf"), meta=i.Meta(mid164, 22)), ], - meta=i.Meta(mid158, 5)), + meta=i.Meta(mid164, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid159, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid165, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-repr_Range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid160, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid166, 6)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid160, 13)), - i.Lookup(kw(u"this"), meta=i.Meta(mid160, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid166, 13)), + i.Lookup(kw(u"this"), meta=i.Meta(mid166, 17)), ], - meta=i.Meta(mid160, 12)), - i.Lookup(kw(u"sbf"), meta=i.Meta(mid160, 23)), + meta=i.Meta(mid166, 12)), + i.Lookup(kw(u"sbf"), meta=i.Meta(mid166, 23)), ], - meta=i.Meta(mid160, 5)), + meta=i.Meta(mid166, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid161, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid167, 4)), i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"-eq_Range"), - body=i.Const(nil), + body=i.VDeref(code.intern_var(u"pixie.stdlib", u"do"), meta=i.Meta(mid168, 25)), ), ], meta=nil), @@ -2953,42 +3064,42 @@ i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid162, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid169, 8)), i.Const(rt.wrap(0)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"MAX-NUMBER"), meta=i.Meta(mid162, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"MAX-NUMBER"), meta=i.Meta(mid169, 18)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid162, 7)), + meta=i.Meta(mid169, 7)), ), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"stop")],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid163, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid170, 12)), i.Const(rt.wrap(0)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid163, 22)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid170, 22)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid163, 11)), + meta=i.Meta(mid170, 11)), ), i.Const(rt.wrap(3)), i.Fn(args=[kw(u"start"),kw(u"stop"),kw(u"step")],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid164, 23)), - i.Lookup(kw(u"start"), meta=i.Meta(mid164, 31)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid164, 37)), - i.Lookup(kw(u"step"), meta=i.Meta(mid164, 42)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid171, 23)), + i.Lookup(kw(u"start"), meta=i.Meta(mid171, 31)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid171, 37)), + i.Lookup(kw(u"step"), meta=i.Meta(mid171, 42)), ], - meta=i.Meta(mid164, 22)), + meta=i.Meta(mid171, 22)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"start"),kw(u"stop")],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid165, 18)), - i.Lookup(kw(u"start"), meta=i.Meta(mid165, 26)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid165, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid172, 18)), + i.Lookup(kw(u"start"), meta=i.Meta(mid172, 26)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid172, 32)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid165, 17)), + meta=i.Meta(mid172, 17)), ), ])]), i.Do( @@ -3015,7 +3126,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid166, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid173, 10)), i.Lookup(kw(u"edit"), meta=nil), i.Lookup(kw(u"array"), meta=nil), ], @@ -3024,21 +3135,21 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid167, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid166, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid174, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid173, 10)), i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_Node"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid168, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid168, 16)), - i.Lookup(kw(u"name"), meta=i.Meta(mid168, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid175, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid175, 16)), + i.Lookup(kw(u"name"), meta=i.Meta(mid175, 21)), ], - meta=i.Meta(mid168, 5)), + meta=i.Meta(mid175, 5)), ), ], meta=nil), ], - meta=i.Meta(mid166, 1)), + meta=i.Meta(mid173, 1)), i.Invoke(args=[ # (def pixie.stdlib/new-node) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -3047,25 +3158,25 @@ i.Const(rt.wrap(1)), i.Fn(args=[kw(u"edit")],name=kw(u"new-node"), body=i.TailCall( args=[ - i.Lookup(kw(u"new-node"), meta=i.Meta(mid169, 5)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid169, 14)), + i.Lookup(kw(u"new-node"), meta=i.Meta(mid176, 5)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid176, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid169, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid176, 20)), i.Const(rt.wrap(32)), ], - meta=i.Meta(mid169, 19)), + meta=i.Meta(mid176, 19)), ], - meta=i.Meta(mid169, 4)), + meta=i.Meta(mid176, 4)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"edit"),kw(u"array")],name=kw(u"new-node"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid170, 5)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid170, 12)), - i.Lookup(kw(u"array"), meta=i.Meta(mid170, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid177, 5)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid177, 12)), + i.Lookup(kw(u"array"), meta=i.Meta(mid177, 17)), ], - meta=i.Meta(mid170, 4)), + meta=i.Meta(mid177, 4)), ), ])]), i.Invoke(args=[ @@ -3074,10 +3185,10 @@ i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY-NODE")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid171, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid178, 18)), i.Const(nil), ], - meta=i.Meta(mid171, 17))]), + meta=i.Meta(mid178, 17))]), i.Invoke(args=[ # (def pixie.stdlib/tailoff) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -3088,40 +3199,40 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid172, 20)), + i.Lookup(kw(u"this"), meta=i.Meta(mid179, 20)), i.Const(kw(u"cnt")), ], - meta=i.Meta(mid172, 13)), + meta=i.Meta(mid179, 13)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid173, 10)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid173, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid180, 10)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid180, 12)), i.Const(rt.wrap(32)), ], - meta=i.Meta(mid173, 9)), + meta=i.Meta(mid180, 9)), then=i.Const(rt.wrap(0)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid174, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid181, 8)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid174, 24)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid181, 24)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid174, 41)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid174, 45)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid181, 41)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid181, 45)), ], - meta=i.Meta(mid174, 40)), + meta=i.Meta(mid181, 40)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid174, 23)), + meta=i.Meta(mid181, 23)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid174, 7)), - meta=i.Meta(mid173, 5)), - meta=i.Meta(mid172, 3)), + meta=i.Meta(mid181, 7)), + meta=i.Meta(mid180, 5)), + meta=i.Meta(mid179, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/array-for) @@ -3132,34 +3243,34 @@ test=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid175, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid182, 17)), i.Const(rt.wrap(0)), - i.Lookup(kw(u"i"), meta=i.Meta(mid175, 22)), + i.Lookup(kw(u"i"), meta=i.Meta(mid182, 22)), ], - meta=i.Meta(mid175, 16)), + meta=i.Meta(mid182, 16)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid175, 26)), - i.Lookup(kw(u"i"), meta=i.Meta(mid175, 28)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid175, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid182, 26)), + i.Lookup(kw(u"i"), meta=i.Meta(mid182, 28)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid182, 30)), ], - meta=i.Meta(mid175, 25)), + meta=i.Meta(mid182, 25)), els=i.Const(nil), - meta=i.Meta(mid175, 11)), + meta=i.Meta(mid182, 11)), then=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">="), meta=i.Meta(mid176, 14)), - i.Lookup(kw(u"i"), meta=i.Meta(mid176, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">="), meta=i.Meta(mid183, 14)), + i.Lookup(kw(u"i"), meta=i.Meta(mid183, 17)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid176, 20)), - i.Lookup(kw(u"this"), meta=i.Meta(mid176, 28)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid183, 20)), + i.Lookup(kw(u"this"), meta=i.Meta(mid183, 28)), ], - meta=i.Meta(mid176, 19)), + meta=i.Meta(mid183, 19)), ], - meta=i.Meta(mid176, 13)), - then=i.Lookup(kw(u"tail"), meta=i.Meta(mid177, 11)), + meta=i.Meta(mid183, 13)), + then=i.Lookup(kw(u"tail"), meta=i.Meta(mid184, 11)), els=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), @@ -3169,65 +3280,65 @@ body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid178, 28)), - i.Lookup(kw(u"level"), meta=i.Meta(mid178, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid185, 28)), + i.Lookup(kw(u"level"), meta=i.Meta(mid185, 30)), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid178, 27)), + meta=i.Meta(mid185, 27)), then=i.TailCall( args=[ - i.Lookup(kw(u"look-deeper"), meta=i.Meta(mid179, 26)), + i.Lookup(kw(u"look-deeper"), meta=i.Meta(mid186, 26)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid179, 39)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid186, 39)), i.Invoke( args=[ i.Const(kw(u"array")), - i.Lookup(kw(u"node"), meta=i.Meta(mid179, 52)), + i.Lookup(kw(u"node"), meta=i.Meta(mid186, 52)), ], - meta=i.Meta(mid179, 44)), + meta=i.Meta(mid186, 44)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid180, 45)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid187, 45)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid180, 54)), - i.Lookup(kw(u"i"), meta=i.Meta(mid180, 70)), - i.Lookup(kw(u"level"), meta=i.Meta(mid180, 72)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid187, 54)), + i.Lookup(kw(u"i"), meta=i.Meta(mid187, 70)), + i.Lookup(kw(u"level"), meta=i.Meta(mid187, 72)), ], - meta=i.Meta(mid180, 53)), + meta=i.Meta(mid187, 53)), i.Const(rt.wrap(31)), ], - meta=i.Meta(mid180, 44)), + meta=i.Meta(mid187, 44)), ], - meta=i.Meta(mid179, 38)), + meta=i.Meta(mid186, 38)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid181, 39)), - i.Lookup(kw(u"level"), meta=i.Meta(mid181, 41)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid188, 39)), + i.Lookup(kw(u"level"), meta=i.Meta(mid188, 41)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid181, 38)), + meta=i.Meta(mid188, 38)), ], - meta=i.Meta(mid179, 25)), + meta=i.Meta(mid186, 25)), els=i.TailCall( args=[ i.Const(kw(u"array")), - i.Lookup(kw(u"node"), meta=i.Meta(mid182, 33)), + i.Lookup(kw(u"node"), meta=i.Meta(mid189, 33)), ], - meta=i.Meta(mid182, 25)), - meta=i.Meta(mid178, 23)), + meta=i.Meta(mid189, 25)), + meta=i.Meta(mid185, 23)), ), - i.Lookup(kw(u"root"), meta=i.Meta(mid183, 21)), - i.Lookup(kw(u"shift"), meta=i.Meta(mid184, 21)), + i.Lookup(kw(u"root"), meta=i.Meta(mid190, 21)), + i.Lookup(kw(u"shift"), meta=i.Meta(mid191, 21)), ], - meta=i.Meta(mid185, 20)), + meta=i.Meta(mid192, 20)), i.Const(kw(u"array")), ], - meta=i.Meta(mid185, 11)), - meta=i.Meta(mid176, 9)), + meta=i.Meta(mid192, 11)), + meta=i.Meta(mid183, 9)), els=i.Const(nil), - meta=i.Meta(mid175, 7)), + meta=i.Meta(mid182, 7)), )]), i.Do( args=[ @@ -3256,7 +3367,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), i.Lookup(kw(u"cnt"), meta=nil), i.Lookup(kw(u"shift"), meta=nil), i.Lookup(kw(u"root"), meta=nil), @@ -3268,69 +3379,397 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid187, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid194, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_PersistentVector"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid188, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid188, 16)), - i.Lookup(kw(u"name"), meta=i.Meta(mid188, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid195, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid195, 16)), + i.Lookup(kw(u"name"), meta=i.Meta(mid195, 21)), ], - meta=i.Meta(mid188, 5)), + meta=i.Meta(mid195, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid189, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid196, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), i.Fn(args=[kw(u"this"),kw(u"val")],name=kw(u"-conj_PersistentVector"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid190, 14)), - i.Invoke( + body=i.Do( + args=[ + i.If( + test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid189, 11)), - i.Const(kw(u"cnt")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid197, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"cnt")), + ], + meta=nil), + i.Const(rt.wrap(4294967295)), + ], + meta=i.Meta(mid197, 13)), + then=i.Const(nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=nil), + i.Const(rt.wrap(u"Assert failed: ")), + i.Const(rt.wrap(u"Vector too large")), + ], + meta=nil), + ]), ], meta=nil), - i.Const(rt.wrap(4294967295)), - ], - meta=i.Meta(mid190, 13)), - then=i.Const(nil), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), + meta=i.Meta(mid197, 5)), + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid198, 10)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid198, 13)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"cnt")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid198, 20)), + i.Lookup(kw(u"this"), meta=i.Meta(mid198, 28)), + ], + meta=i.Meta(mid198, 19)), + ], + meta=i.Meta(mid198, 12)), + i.Const(rt.wrap(32)), + ], + meta=i.Meta(mid198, 9)), + then=i.Let(names=[kw(u"new-tail")], + bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=nil), - i.Const(rt.wrap(u"Assert failed: ")), - i.Const(rt.wrap(u"Vector too large")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-append"), meta=i.Meta(mid199, 23)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"tail")), + ], + meta=nil), + i.Lookup(kw(u"val"), meta=i.Meta(mid199, 41)), ], - meta=nil), - ]), - ], - meta=nil), - meta=i.Meta(mid190, 5)), + meta=i.Meta(mid199, 22)), + ], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid200, 10)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid200, 30)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid200, 29)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"root")), + ], + meta=nil), + i.Lookup(kw(u"new-tail"), meta=i.Meta(mid200, 50)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"meta")), + ], + meta=nil), + ], + meta=i.Meta(mid200, 9)), + meta=i.Meta(mid199, 7)), + els=i.Let(names=[kw(u"tail-node")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid201, 24)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"root")), + ], + meta=nil), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid201, 31)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"tail")), + ], + meta=nil), + ], + meta=i.Meta(mid201, 23)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid202, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid202, 17)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"cnt")), + ], + meta=nil), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid202, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid202, 41)), + i.Const(rt.wrap(1)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"shift")), + ], + meta=nil), + ], + meta=i.Meta(mid202, 40)), + ], + meta=i.Meta(mid202, 13)), + then=i.Let(names=[kw(u"new-root")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid203, 27)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"root")), + ], + meta=nil), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid203, 36)), + ], + meta=i.Meta(mid203, 26)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid204, 14)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid204, 19)), + i.Const(rt.wrap(0)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"root")), + ], + meta=nil), + ], + meta=i.Meta(mid204, 13)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid205, 14)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid205, 19)), + i.Const(rt.wrap(1)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid205, 31)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"root")), + ], + meta=nil), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid205, 40)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid205, 60)), + ], + meta=i.Meta(mid205, 30)), + ], + meta=i.Meta(mid205, 13)), + i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid206, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid206, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid206, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid207, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid207, 33)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid208, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid209, 34)), + i.Lookup(kw(u"val"), meta=i.Meta(mid209, 40)), + ], + meta=i.Meta(mid209, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"meta")), + ], + meta=nil), + ], + meta=i.Meta(mid206, 13)), + ], + meta=nil), + meta=i.Meta(mid203, 11)), + els=i.Let(names=[kw(u"new-root")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"push-tail"), meta=i.Meta(mid210, 27)), + i.Lookup(kw(u"this"), meta=i.Meta(mid210, 37)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"root")), + ], + meta=nil), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid210, 53)), + ], + meta=i.Meta(mid210, 26)), + ], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid211, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid211, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid211, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid212, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid213, 34)), + i.Lookup(kw(u"val"), meta=i.Meta(mid213, 40)), + ], + meta=i.Meta(mid213, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Const(kw(u"meta")), + ], + meta=nil), + ], + meta=i.Meta(mid211, 13)), + meta=i.Meta(mid210, 11)), + meta=i.Meta(mid202, 9)), + meta=i.Meta(mid201, 7)), + meta=i.Meta(mid198, 5)), + ], + meta=nil), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid191, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid186, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid214, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), i.Fn(args=[kw(u"this")],name=kw(u"-count_PersistentVector"), body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid191, 12)), + i.Lookup(kw(u"this"), meta=i.Meta(mid214, 12)), i.Const(kw(u"cnt")), ], meta=nil), @@ -3338,7 +3777,7 @@ ], meta=nil), ], - meta=i.Meta(mid186, 1)), + meta=i.Meta(mid193, 1)), i.Invoke(args=[ # (def pixie.stdlib/push-tail) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -3348,144 +3787,144 @@ bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid192, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid215, 17)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid192, 26)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid215, 26)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid192, 43)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid215, 43)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid192, 54)), + i.Lookup(kw(u"this"), meta=i.Meta(mid215, 54)), i.Const(kw(u"cnt")), ], - meta=i.Meta(mid192, 47)), + meta=i.Meta(mid215, 47)), ], - meta=i.Meta(mid192, 42)), - i.Lookup(kw(u"level"), meta=i.Meta(mid192, 61)), + meta=i.Meta(mid215, 42)), + i.Lookup(kw(u"level"), meta=i.Meta(mid215, 61)), ], - meta=i.Meta(mid192, 25)), + meta=i.Meta(mid215, 25)), i.Const(rt.wrap(31)), ], - meta=i.Meta(mid192, 16)), + meta=i.Meta(mid215, 16)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aclone"), meta=i.Meta(mid193, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aclone"), meta=i.Meta(mid216, 20)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"parent"), meta=i.Meta(mid193, 36)), + i.Lookup(kw(u"parent"), meta=i.Meta(mid216, 36)), i.Const(kw(u"array")), ], - meta=i.Meta(mid193, 27)), + meta=i.Meta(mid216, 27)), ], - meta=i.Meta(mid193, 19)), + meta=i.Meta(mid216, 19)), i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid194, 29)), - i.Lookup(kw(u"level"), meta=i.Meta(mid194, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid217, 29)), + i.Lookup(kw(u"level"), meta=i.Meta(mid217, 31)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid194, 28)), - then=i.Lookup(kw(u"tail-node"), meta=i.Meta(mid195, 26)), + meta=i.Meta(mid217, 28)), + then=i.Lookup(kw(u"tail-node"), meta=i.Meta(mid218, 26)), els=i.Let(names=[kw(u"child")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid196, 39)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid219, 39)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"parent"), meta=i.Meta(mid196, 53)), + i.Lookup(kw(u"parent"), meta=i.Meta(mid219, 53)), i.Const(kw(u"array")), ], - meta=i.Meta(mid196, 44)), - i.Lookup(kw(u"subidx"), meta=i.Meta(mid196, 61)), + meta=i.Meta(mid219, 44)), + i.Lookup(kw(u"subidx"), meta=i.Meta(mid219, 61)), ], - meta=i.Meta(mid196, 38)), + meta=i.Meta(mid219, 38)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid197, 33)), - i.Lookup(kw(u"child"), meta=i.Meta(mid197, 35)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid220, 33)), + i.Lookup(kw(u"child"), meta=i.Meta(mid220, 35)), i.Const(nil), ], - meta=i.Meta(mid197, 32)), + meta=i.Meta(mid220, 32)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid198, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid221, 31)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid198, 56)), + i.Lookup(kw(u"this"), meta=i.Meta(mid221, 56)), i.Const(kw(u"root")), ], - meta=i.Meta(mid198, 48)), + meta=i.Meta(mid221, 48)), i.Const(kw(u"edit")), ], - meta=i.Meta(mid198, 40)), + meta=i.Meta(mid221, 40)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid199, 41)), - i.Lookup(kw(u"level"), meta=i.Meta(mid199, 43)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid222, 41)), + i.Lookup(kw(u"level"), meta=i.Meta(mid222, 43)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid199, 40)), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid200, 40)), + meta=i.Meta(mid222, 40)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid223, 40)), ], - meta=i.Meta(mid198, 30)), + meta=i.Meta(mid221, 30)), els=i.Invoke( args=[ - i.Lookup(kw(u"push-tail"), meta=i.Meta(mid201, 31)), - i.Lookup(kw(u"this"), meta=i.Meta(mid201, 41)), + i.Lookup(kw(u"push-tail"), meta=i.Meta(mid224, 31)), + i.Lookup(kw(u"this"), meta=i.Meta(mid224, 41)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid202, 42)), - i.Lookup(kw(u"level"), meta=i.Meta(mid202, 44)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid225, 42)), + i.Lookup(kw(u"level"), meta=i.Meta(mid225, 44)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid202, 41)), - i.Lookup(kw(u"child"), meta=i.Meta(mid203, 41)), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid204, 41)), + meta=i.Meta(mid225, 41)), + i.Lookup(kw(u"child"), meta=i.Meta(mid226, 41)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid227, 41)), ], - meta=i.Meta(mid201, 30)), - meta=i.Meta(mid197, 28)), - meta=i.Meta(mid196, 26)), - meta=i.Meta(mid194, 24)), + meta=i.Meta(mid224, 30)), + meta=i.Meta(mid220, 28)), + meta=i.Meta(mid219, 26)), + meta=i.Meta(mid217, 24)), ], body=i.Do( args=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid205, 6)), - i.Lookup(kw(u"ret-array"), meta=i.Meta(mid205, 11)), - i.Lookup(kw(u"subidx"), meta=i.Meta(mid205, 21)), - i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid205, 28)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid228, 6)), + i.Lookup(kw(u"ret-array"), meta=i.Meta(mid228, 11)), + i.Lookup(kw(u"subidx"), meta=i.Meta(mid228, 21)), + i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid228, 28)), ], - meta=i.Meta(mid205, 5)), + meta=i.Meta(mid228, 5)), i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid206, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid229, 6)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"parent"), meta=i.Meta(mid206, 21)), + i.Lookup(kw(u"parent"), meta=i.Meta(mid229, 21)), i.Const(kw(u"edit")), ], - meta=i.Meta(mid206, 13)), - i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid206, 29)), + meta=i.Meta(mid229, 13)), + i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid229, 29)), ], - meta=i.Meta(mid206, 5)), + meta=i.Meta(mid229, 5)), ], meta=nil), - meta=i.Meta(mid192, 3)), + meta=i.Meta(mid215, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/new-path) @@ -3495,33 +3934,33 @@ body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid207, 8)), - i.Lookup(kw(u"level"), meta=i.Meta(mid207, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid230, 8)), + i.Lookup(kw(u"level"), meta=i.Meta(mid230, 10)), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid207, 7)), - then=i.Lookup(kw(u"node"), meta=i.Meta(mid208, 5)), + meta=i.Meta(mid230, 7)), + then=i.Lookup(kw(u"node"), meta=i.Meta(mid231, 5)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid209, 6)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid209, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid232, 6)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid232, 13)), i.Invoke( args=[ - i.Lookup(kw(u"new-path"), meta=i.Meta(mid210, 14)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid210, 23)), + i.Lookup(kw(u"new-path"), meta=i.Meta(mid233, 14)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid233, 23)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid210, 29)), - i.Lookup(kw(u"level"), meta=i.Meta(mid210, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid233, 29)), + i.Lookup(kw(u"level"), meta=i.Meta(mid233, 31)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid210, 28)), - i.Lookup(kw(u"node"), meta=i.Meta(mid210, 40)), + meta=i.Meta(mid233, 28)), + i.Lookup(kw(u"node"), meta=i.Meta(mid233, 40)), ], - meta=i.Meta(mid210, 13)), + meta=i.Meta(mid233, 13)), ], - meta=i.Meta(mid209, 5)), - meta=i.Meta(mid207, 3)), + meta=i.Meta(mid232, 5)), + meta=i.Meta(mid230, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/EMPTY) @@ -3529,203 +3968,219 @@ i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid211, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid234, 13)), i.Const(rt.wrap(0)), i.Const(rt.wrap(5)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid211, 36)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid234, 36)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid211, 48)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid234, 48)), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid211, 47)), + meta=i.Meta(mid234, 47)), i.Const(nil), ], - meta=i.Meta(mid211, 12))]), + meta=i.Meta(mid234, 12))]), i.Invoke(args=[ # (def pixie.stdlib/vector-from-array) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), i.Const(code.intern_var(u"pixie.stdlib",u"vector-from-array")), i.Fn(args=[kw(u"arr")],name=kw(u"vector-from-array"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid212, 8)), - i.Invoke( + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid235, 4)), + i.Const(rt.wrap(u"Vector for array")), + ], + meta=i.Meta(mid235, 3)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid236, 4)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid236, 13)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid236, 19)), + ], + meta=i.Meta(mid236, 12)), + ], + meta=i.Meta(mid236, 3)), + i.If( + test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid212, 11)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid212, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid237, 8)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid237, 11)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid237, 17)), + ], + meta=i.Meta(mid237, 10)), + i.Const(rt.wrap(32)), ], - meta=i.Meta(mid212, 10)), - i.Const(rt.wrap(32)), - ], - meta=i.Meta(mid212, 7)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid213, 6)), - i.Invoke( + meta=i.Meta(mid237, 7)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid238, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid238, 26)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid238, 32)), + ], + meta=i.Meta(mid238, 25)), + i.Const(rt.wrap(5)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid238, 39)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid238, 50)), + i.Const(nil), + ], + meta=i.Meta(mid238, 5)), + els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid213, 26)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid213, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid239, 6)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), + i.Lookup(kw(u"arr"), meta=i.Meta(mid239, 14)), ], - meta=i.Meta(mid213, 25)), - i.Const(rt.wrap(5)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid213, 39)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid213, 50)), - i.Const(nil), - ], - meta=i.Meta(mid213, 5)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid214, 6)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), - i.Lookup(kw(u"arr"), meta=i.Meta(mid214, 14)), - ], - meta=i.Meta(mid214, 5)), - meta=i.Meta(mid212, 3)), + meta=i.Meta(mid239, 5)), + meta=i.Meta(mid237, 3)), + ], + meta=nil), )]), i.Do( args=[ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid215, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid216, 14)), - i.Fn(args=[kw(u"this"),kw(u"f"),kw(u"init")],name=kw(u"fn_528"), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid240, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid241, 14)), + i.Fn(args=[kw(u"this"),kw(u"f"),kw(u"init")],name=kw(u"fn_533"), body=i.Let(names=[kw(u"idx"),kw(u"acc")], bindings=[ i.Const(rt.wrap(0)), - i.Lookup(kw(u"init"), meta=i.Meta(mid217, 16)), + i.Lookup(kw(u"init"), meta=i.Meta(mid242, 16)), ], body=i.TailCall( args=[ i.Fn(args=[kw(u"idx"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"this"),kw(u"f")], body=i.Let(names=[kw(u"idx"),kw(u"acc")], bindings=[ - i.Lookup(kw(u"idx"), meta=i.Meta(mid218, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid217, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid243, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid242, 12)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid219, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid219, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid244, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid244, 21)), ], - meta=i.Meta(mid219, 11)), + meta=i.Meta(mid244, 11)), then=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), - i.Lookup(kw(u"acc"), meta=i.Meta(mid220, 10)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid245, 10)), ], - meta=i.Meta(mid220, 9)), + meta=i.Meta(mid245, 9)), els=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid221, 14)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid221, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid246, 14)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid246, 16)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid221, 21)), - i.Lookup(kw(u"this"), meta=i.Meta(mid221, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid246, 21)), + i.Lookup(kw(u"this"), meta=i.Meta(mid246, 27)), ], - meta=i.Meta(mid221, 20)), + meta=i.Meta(mid246, 20)), ], - meta=i.Meta(mid221, 13)), + meta=i.Meta(mid246, 13)), then=i.TailCall( args=[ i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid222, 19)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid222, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid247, 19)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid247, 23)), ], - meta=i.Meta(mid222, 18)), + meta=i.Meta(mid247, 18)), i.Invoke( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid223, 19)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid223, 21)), + i.Lookup(kw(u"f"), meta=i.Meta(mid248, 19)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid248, 21)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid223, 26)), - i.Lookup(kw(u"this"), meta=i.Meta(mid223, 31)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid223, 36)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid248, 26)), + i.Lookup(kw(u"this"), meta=i.Meta(mid248, 31)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid248, 36)), ], - meta=i.Meta(mid223, 25)), + meta=i.Meta(mid248, 25)), ], - meta=i.Meta(mid223, 18)), + meta=i.Meta(mid248, 18)), ], meta=nil), - els=i.Lookup(kw(u"acc"), meta=i.Meta(mid224, 11)), - meta=i.Meta(mid221, 9)), - meta=i.Meta(mid219, 7)), + els=i.Lookup(kw(u"acc"), meta=i.Meta(mid249, 11)), + meta=i.Meta(mid246, 9)), + meta=i.Meta(mid244, 7)), meta=nil), ), - i.Lookup(kw(u"idx"), meta=i.Meta(mid218, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid217, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid243, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid242, 12)), ], meta=nil), - meta=i.Meta(mid218, 5)), + meta=i.Meta(mid243, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid225, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid216, 14)), - i.Fn(args=[kw(u"arr")],name=kw(u"fn_532"), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid250, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid241, 14)), + i.Fn(args=[kw(u"arr")],name=kw(u"fn_537"), body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"arr"), meta=i.Meta(mid226, 21)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid251, 21)), i.Const(kw(u"count")), ], - meta=i.Meta(mid226, 12)), + meta=i.Meta(mid251, 12)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid227, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid216, 14)), - i.Fn(args=[kw(u"arr"),kw(u"itm")],name=kw(u"fn_524"), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid252, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid241, 14)), + i.Fn(args=[kw(u"arr"),kw(u"itm")],name=kw(u"fn_529"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid228, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid253, 6)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"vector-from-array"), meta=i.Meta(mid228, 18)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid228, 36)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"vector-from-array"), meta=i.Meta(mid253, 12)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid253, 30)), ], - meta=i.Meta(mid228, 17)), - i.Lookup(kw(u"itm"), meta=i.Meta(mid228, 41)), + meta=i.Meta(mid253, 11)), + i.Lookup(kw(u"itm"), meta=i.Meta(mid253, 35)), ], - meta=i.Meta(mid228, 11)), + meta=i.Meta(mid253, 5)), ), ], meta=nil), ], - meta=i.Meta(mid216, 1)), + meta=i.Meta(mid241, 1)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid229, 2)), - i.Const(rt.wrap(42)), - ], - meta=i.Meta(mid229, 1)), - i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid230, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid254, 2)), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid230, 11)), - i.Const(rt.wrap(1000)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid254, 11)), + i.Const(rt.wrap(4)), ], - meta=i.Meta(mid230, 10)), + meta=i.Meta(mid254, 10)), ], - meta=i.Meta(mid230, 1)), + meta=i.Meta(mid254, 1)), + i.Const(nil), ], -meta=i.Meta(mid231, 1)) \ No newline at end of file +meta=i.Meta(mid255, 1)) \ No newline at end of file diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index ec76afbb..95e52eb1 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -337,6 +337,7 @@ (loop [i start acc init] (println i) + (println acc) (if (or (and (> step 0) (< i stop)) (and (< step 0) (> i stop)) (and (= step 0))) @@ -441,11 +442,13 @@ (-conj [this val] (assert (< cnt 0xFFFFFFFF) "Vector too large") - (if (< (- cnt (tailoff self)) 32) + (if (< (- cnt (tailoff this)) 32) (let [new-tail (array-append tail val)] (->PersistentVector (inc cnt) shift root new-tail meta)) + (let [tail-node (->Node (.-edit root) tail)] (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift)) + (let [new-root (new-node (.-edit root))] (aset new-root 0 root) (aset new-root 1 (new-path (.-edit root) shift tail-node)) @@ -492,6 +495,8 @@ (def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil)) (defn vector-from-array [arr] + (println "Vector for array") + (println (count arr)) (if (< (count arr) 32) (->PersistentVector (count arr) 5 EMPTY-NODE arr nil) (into [] arr))) @@ -500,8 +505,9 @@ (extend-type Array IPersistentCollection - (-conj ([arr itm] - (conj (vector-from-array arr) itm))) + (-conj [arr itm] + (conj (vector-from-array arr) itm)) + ICounted (-count ([arr] (.-count arr))) @@ -520,12 +526,23 @@ ;;; -(println 42) +(into [] (range 4)) + +(comment + (println 42) + + #_(into [] (range 4)) + + + (println ( (fn [x] + (assert (< x 0xFFFFFFFF) "Vector too large") + + (if true + 11 + 2)) 0)) -(into [] (range 1000)) + (println ((fn [] + (if true nil (println 100)) + 11))) -#_(let [v EMPTY] - (loop [acc EMPTY - i 0] - (if (< i 1000) - (recur (conj v i) (inc i))))) + (println 44)) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 4bb19b9f..96a4d64d 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -75,6 +75,8 @@ (defmulti analyze-form (fn [x] (cond + (identical? x true) :bool + (identical? x false) :bool (nil? x) nil (seq? x) :seq (vector? x) :vector @@ -249,12 +251,12 @@ :form val}) (defmethod analyze-seq 'local-macro - [[_ [nm replace] body :as form]] + [[_ [nm replace] & body :as form]] (binding [*env* (assoc-in *env* [:locals nm] {:op :local-macro :name nm :replace-with replace :form form})] - (analyze-form body))) + (analyze-form (cons 'do body)))) (defmethod analyze-form nil [_] @@ -263,6 +265,13 @@ :env *env* :form nil}) +(defmethod analyze-form :bool + [form] + {:op :const + :type :bool + :env *env* + :form form}) + (defn keep-meta [new old] (if-let [md (meta old)] (if (satisfies? IMeta new) @@ -530,6 +539,12 @@ (write! sb (str form)) (write! sb ")")) +(defmethod write-const :bool + [sb offset {:keys [form]}] + (if form + (write! sb "true") + (write! sb "false"))) + (defmethod to-rpython :const [sb offset ast] (write! sb "i.Const(") diff --git a/target2.py b/target2.py index e1a075fb..ca73db71 100644 --- a/target2.py +++ b/target2.py @@ -2,7 +2,7 @@ import pixie.vm2.interpreter as i from pixie.vm2.object import StackCell, run_stack import pixie.vm2.rt as rt -from pixie.vm2.primitives import nil +from pixie.vm2.primitives import nil, true, false import pixie.vm2.code as code from pixie.vm2.keyword import keyword as kw from pixie.vm2.symbol import symbol as sym From 7ef1da6270d96e68ae516cb5aa5b0b2f89390a4c Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sun, 17 May 2015 14:57:31 -0600 Subject: [PATCH 11/46] more vector debugging added some missing files --- bootstrap.py | 209 ++++++++++++++++++++++++++-- pixie/bootstrap.pxi | 20 ++- pixie/vm2/array.py | 16 ++- pixie/vm2/bits.py | 91 +++++++++++++ pixie/vm2/custom_types.py | 265 ++++++++++++++++++++++++++++++++++++ pixie/vm2/rt.py | 4 +- pixie/vm2/stdlib.py | 175 ++++++++++++++++++++++++ pixie/vm2/string_builder.py | 21 +++ pixie/vm2/symbol.py | 103 ++++++++++++++ 9 files changed, 883 insertions(+), 21 deletions(-) create mode 100644 pixie/vm2/bits.py create mode 100644 pixie/vm2/custom_types.py create mode 100644 pixie/vm2/stdlib.py create mode 100644 pixie/vm2/string_builder.py create mode 100644 pixie/vm2/symbol.py diff --git a/bootstrap.py b/bootstrap.py index 98143394..834ed993 100755 --- a/bootstrap.py +++ b/bootstrap.py @@ -214,7 +214,7 @@ mid213 = (u""" (array val)""", "", 464) mid214 = (u""" (-count [this] cnt))""", "", 468) mid215 = (u""" (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f)""", "", 472) -mid216 = (u""" ret-array (aclone (.-array parent))""", "", 473) +mid216 = (u""" ret-array (array-clone (.-array parent))""", "", 473) mid217 = (u""" node-to-insert (if (= level 5)""", "", 474) mid218 = (u""" tail-node""", "", 475) mid219 = (u""" (let [child (aget (.-array parent) subidx)]""", "", 476) @@ -252,8 +252,19 @@ mid251 = (u""" (.-count arr)))""", "", 513) mid252 = (u""" (-conj [arr itm]""", "", 508) mid253 = (u""" (conj (vector-from-array arr) itm))""", "", 509) -mid254 = (u"""(into [] (range 4))""", "", 529) -mid255 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) +mid254 = (u""" (loop [idx 0]""", "", 527) +mid255 = (u""" (when (< idx size)""", "", 528) +mid256 = (u""" (do (aset to (+ to-idx idx) (aget from (+ from-idx idx)))""", "", 529) +mid257 = (u""" (recur (inc idx))))))""", "", 530) +mid258 = (u""" (let [new-array (make-array (inc (count arr)))]""", "", 533) +mid259 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 534) +mid260 = (u""" (aset new-array (count arr) val)""", "", 535) +mid261 = (u""" new-array))""", "", 536) +mid262 = (u""" (let [new-array (make-array (count arr))]""", "", 539) +mid263 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 540) +mid264 = (u""" new-array))""", "", 541) +mid265 = (u"""(into [] (range 40))""", "", 545) +mid266 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) code_ast=i.Do( @@ -3811,14 +3822,14 @@ meta=i.Meta(mid215, 16)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aclone"), meta=i.Meta(mid216, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-clone"), meta=i.Meta(mid216, 20)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"parent"), meta=i.Meta(mid216, 36)), + i.Lookup(kw(u"parent"), meta=i.Meta(mid216, 41)), i.Const(kw(u"array")), ], - meta=i.Meta(mid216, 27)), + meta=i.Meta(mid216, 32)), ], meta=i.Meta(mid216, 19)), i.If( @@ -4168,19 +4179,193 @@ meta=nil), ], meta=i.Meta(mid241, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/array-copy) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"array-copy")), + i.Fn(args=[kw(u"from"),kw(u"from-idx"),kw(u"to"),kw(u"to-idx"),kw(u"size")],name=kw(u"array-copy"), + body=i.Let(names=[kw(u"idx")], + bindings=[ + i.Const(rt.wrap(0)), + ], + body=i.TailCall( + args=[ + i.Fn(args=[kw(u"idx")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"size"),kw(u"from-idx"),kw(u"to"),kw(u"to-idx"),kw(u"from")], + body=i.Let(names=[kw(u"idx")], + bindings=[ + i.Lookup(kw(u"idx"), meta=i.Meta(mid254, 10)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid255, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid255, 14)), + i.Lookup(kw(u"size"), meta=i.Meta(mid255, 18)), + ], + meta=i.Meta(mid255, 11)), + then=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid256, 12)), + i.Lookup(kw(u"to"), meta=i.Meta(mid256, 17)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid256, 21)), + i.Lookup(kw(u"to-idx"), meta=i.Meta(mid256, 23)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid256, 30)), + ], + meta=i.Meta(mid256, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid256, 36)), + i.Lookup(kw(u"from"), meta=i.Meta(mid256, 41)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid256, 47)), + i.Lookup(kw(u"from-idx"), meta=i.Meta(mid256, 49)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid256, 58)), + ], + meta=i.Meta(mid256, 46)), + ], + meta=i.Meta(mid256, 35)), + ], + meta=i.Meta(mid256, 11)), + i.TailCall( + args=[ + i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid257, 19)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid257, 23)), + ], + meta=i.Meta(mid257, 18)), + ], + meta=nil), + ], + meta=i.Meta(mid256, 7)), + els=i.Const(nil), + meta=i.Meta(mid255, 5)), + meta=nil), + ), + i.Lookup(kw(u"idx"), meta=i.Meta(mid254, 10)), + ], + meta=nil), + meta=i.Meta(mid254, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/array-append) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"array-append")), + i.Fn(args=[kw(u"arr"),kw(u"val")],name=kw(u"array-append"), + body=i.Let(names=[kw(u"new-array")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid258, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid258, 32)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid258, 37)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid258, 43)), + ], + meta=i.Meta(mid258, 36)), + ], + meta=i.Meta(mid258, 31)), + ], + meta=i.Meta(mid258, 19)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid259, 6)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid259, 17)), + i.Const(rt.wrap(0)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid259, 23)), + i.Const(rt.wrap(0)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid259, 36)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid259, 42)), + ], + meta=i.Meta(mid259, 35)), + ], + meta=i.Meta(mid259, 5)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid260, 6)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid260, 11)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid260, 22)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid260, 28)), + ], + meta=i.Meta(mid260, 21)), + i.Lookup(kw(u"val"), meta=i.Meta(mid260, 33)), + ], + meta=i.Meta(mid260, 5)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid261, 5)), + ], + meta=nil), + meta=i.Meta(mid258, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/array-clone) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"array-clone")), + i.Fn(args=[kw(u"arr")],name=kw(u"array-clone"), + body=i.Let(names=[kw(u"new-array")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid262, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid262, 32)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid262, 38)), + ], + meta=i.Meta(mid262, 31)), + ], + meta=i.Meta(mid262, 19)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid263, 6)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid263, 17)), + i.Const(rt.wrap(0)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid263, 23)), + i.Const(rt.wrap(0)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid263, 36)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid263, 42)), + ], + meta=i.Meta(mid263, 35)), + ], + meta=i.Meta(mid263, 5)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid264, 5)), + ], + meta=nil), + meta=i.Meta(mid262, 3)), + )]), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid254, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid265, 2)), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid254, 11)), - i.Const(rt.wrap(4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid265, 11)), + i.Const(rt.wrap(40)), ], - meta=i.Meta(mid254, 10)), + meta=i.Meta(mid265, 10)), ], - meta=i.Meta(mid254, 1)), + meta=i.Meta(mid265, 1)), i.Const(nil), ], -meta=i.Meta(mid255, 1)) \ No newline at end of file +meta=i.Meta(mid266, 1)) \ No newline at end of file diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 95e52eb1..dd3205bf 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -470,7 +470,7 @@ (defn push-tail [this level parent tail-node] (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f) - ret-array (aclone (.-array parent)) + ret-array (array-clone (.-array parent)) node-to-insert (if (= level 5) tail-node (let [child (aget (.-array parent) subidx)] @@ -523,10 +523,26 @@ (f acc (aget this idx))) acc))))) +(defn array-copy [from from-idx to to-idx size] + (loop [idx 0] + (when (< idx size) + (do (aset to (+ to-idx idx) (aget from (+ from-idx idx))) + (recur (inc idx)))))) + +(defn array-append [arr val] + (let [new-array (make-array (inc (count arr)))] + (array-copy arr 0 new-array 0 (count arr)) + (aset new-array (count arr) val) + new-array)) + +(defn array-clone [arr] + (let [new-array (make-array (count arr))] + (array-copy arr 0 new-array 0 (count arr)) + new-array)) ;;; -(into [] (range 4)) +(into [] (range 40)) (comment (println 42) diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py index c1498152..8d48285b 100644 --- a/pixie/vm2/array.py +++ b/pixie/vm2/array.py @@ -49,6 +49,9 @@ def get_field(self, k): def array__args(lst): return Array(lst) +@as_var("make-array") +def _make_array(size): + return Array([nil] * size.int_val()) #@extend(proto._count, Array) #def _count(self): @@ -143,12 +146,13 @@ def array__args(lst): def aget(self, idx): assert isinstance(self, Array) return self._list[idx.int_val()] -# -# @as_var("aset") -# def aset(self, idx, val): -# assert isinstance(self, Array) -# self._list[idx.int_val()] = val -# return val + +@as_var("aset") +def aset(self, idx, val): + assert isinstance(self, Array) + self._list[idx.int_val()] = val + return val + # # @as_var("aslice") # def aslice(self, offset): diff --git a/pixie/vm2/bits.py b/pixie/vm2/bits.py new file mode 100644 index 00000000..81f8c8d8 --- /dev/null +++ b/pixie/vm2/bits.py @@ -0,0 +1,91 @@ +from pixie.vm2.code import as_var +from pixie.vm2.object import affirm + +from pixie.vm2.numbers import Integer +from rpython.rlib.rarithmetic import intmask + +import pixie.vm2.rt as rt + +@as_var("bit-clear") +def bit_clear(x, n): + affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") + return rt.wrap(x.int_val() & ~(1 << n.int_val())) + +@as_var("bit-set") +def bit_set(x, n): + affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") + return rt.wrap(x.int_val() | (1 << n.int_val())) + +@as_var("bit-flip") +def bit_flip(x, n): + affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") + return rt.wrap(x.int_val() ^ (1 << n.int_val())) + +@as_var("bit-not") +def bit_not(x): + affirm(isinstance(x, Integer), u"x must be an Integer") + return rt.wrap(~x.int_val()) + +@as_var("bit-test") +def bit_test(x, n): + affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") + return rt.wrap((x.int_val() & (1 << n.int_val())) != 0) + +@as_var("bit-and") +def bit_and(x, y): + affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") + return rt.wrap(x.int_val() & y.int_val()) + +@as_var("bit-and-not") +def bit_and_not(x, y): + affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") + return rt.wrap(x.int_val() & ~y.int_val()) + +@as_var("bit-or") +def bit_or(x, y): + affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") + return rt.wrap(x.int_val() | y.int_val()) + +@as_var("bit-xor") +def bit_xor(x, y): + affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") + return rt.wrap(x.int_val() ^ y.int_val()) + +@as_var("bit-shift-left") +def bit_shift_left(x, n): + affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") + return rt.wrap(x.int_val() << n.int_val()) + +@as_var("bit-shift-right") +def bit_shift_right(x, n): + affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") + return rt.wrap(x.int_val() >> n.int_val()) + +@as_var("unsigned-bit-shift-right") +def unsigned_bit_shift_right(x, n): + affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") + return rt.wrap(intmask(x.r_uint_val() >> n.int_val())) + +digits = "0123456789abcdefghijklmnopqrstuvwxyz" + +@as_var("bit-str") +def bit_str(x, shift): + affirm(isinstance(x, Integer) and isinstance(shift, Integer), u"x and shift must be Integers") + x = x.int_val() + shift = shift.int_val() + + buf = ['_'] * 32 + char_pos = 32 + radix = 1 << shift + mask = radix - 1 + while True: + char_pos -= 1 + buf[char_pos] = digits[x & mask] + x = x >> shift + if x == 0: + break + + res = "" + for i in range(char_pos, char_pos + 32 - char_pos): + res += buf[i] + return rt.wrap(res) diff --git a/pixie/vm2/custom_types.py b/pixie/vm2/custom_types.py new file mode 100644 index 00000000..0a6e0434 --- /dev/null +++ b/pixie/vm2/custom_types.py @@ -0,0 +1,265 @@ +from pixie.vm2.object import Object, Type, affirm, runtime_error +import rpython.rlib.jit as jit +from rpython.rlib.rarithmetic import r_uint +from pixie.vm2.code import as_var +from pixie.vm2.numbers import Integer, Float +from pixie.vm2.keyword import Keyword +from pixie.vm2.array import Array +import pixie.vm2.rt as rt + +MAX_FIELDS = 32 + + +class CustomType(Type): + _immutable_fields_ = ["_slots", "_rev?"] + def __init__(self, name, slots): + Type.__init__(self, name) + + self._slots = slots + self._mutable_slots = {} + self._rev = 0 + + @jit.elidable_promote() + def get_slot_idx(self, nm): + return self._slots.get(nm, -1) + + def set_mutable(self, nm): + if not self.is_mutable(nm): + self._rev += 1 + self._mutable_slots[nm] = nm + + + @jit.elidable_promote() + def _is_mutable(self, nm, rev): + return nm in self._mutable_slots + + def is_mutable(self, nm): + return self._is_mutable(nm, self._rev) + + @jit.elidable_promote() + def get_num_slots(self): + return len(self._slots) + + def custom_type_name(self): + return self._name + +class CustomTypeInstance(Object): + _immutable_fields_ = ["_type"] + def __init__(self, type): + affirm(isinstance(type, CustomType), u"Can't create a instance of a non custom type") + self._custom_type = type + + def type(self): + return self._custom_type + + def set_field(self, name, val): + idx = self._custom_type.get_slot_idx(name) + assert isinstance(name, Keyword) + if idx == -1: + runtime_error(u"Invalid field named " + name._str + u" on type " + self._custom_type.custom_type_name(), + u"pixie.stdlib/InvalidFieldException") + + old_val = self.get_field_by_idx(idx) + if isinstance(old_val, AbstractMutableCell): + old_val.set_mutable_cell_value(self._custom_type, self, name, idx, val) + else: + self._custom_type.set_mutable(name) + self.set_field_by_idx(idx, val) + return self + + @jit.elidable_promote() + def _get_field_immutable(self, idx, rev): + return self.get_field_by_idx(idx) + + def get_field_immutable(self, idx): + tp = self._custom_type + assert isinstance(tp, CustomType) + return self._get_field_immutable(idx, tp._rev) + + def get_field(self, name): + idx = self._custom_type.get_slot_idx(name) + assert isinstance(name, Keyword) + if idx == -1: + runtime_error(u"Invalid field named " + rt.unwrap_keyword(name) + u" on type " + self._custom_type.custom_type_name(), + u"pixie.stdlib/InvalidFieldException") + + if self._custom_type.is_mutable(name): + value = self.get_field_by_idx(idx) + else: + value = self.get_field_immutable(idx) + + if isinstance(value, AbstractMutableCell): + return value.get_mutable_cell_value() + else: + return value + + +create_type_prefix = """ +def new_inst(tp, fields): + l = len(fields) + if l >= {max_c}: + runtime_error(u"Too many fields for type", u"pixie.stdlib/TooManyFields") +""" + +clause_template = """ + elif l == {c}: + return CustomType{c}(tp, fields) +""" + +def gen_ct_code(): + acc = create_type_prefix.format(max_c=MAX_FIELDS + 1) + for x in range(MAX_FIELDS + 1): + acc += clause_template.format(c=x) + + #print acc + return acc + +exec gen_ct_code() + + +type_template = """ +class CustomType{c}(CustomTypeInstance): + def __init__(self, tp, fields): + CustomTypeInstance.__init__(self, tp) + {self_fields_list} = fields + + def get_field_by_idx(self, idx): + if idx >= {max}: + return None +""" + +get_field_by_idx_template = """ + elif idx == {c}: + return self._custom_field{c} +""" + +set_field_prefix_template = """ + def set_field_by_idx(self, idx, val): + if idx >= {max}: + return +""" + +set_field_by_idx_template = """ + elif idx == {c}: + self._custom_field{c} = val +""" + +def gen_ct_class_code(): + acc = "" + for x in range(MAX_FIELDS + 1): + if x == 0: + self_fields_list = "_null_" + elif x == 1: + self_fields_list = "self._custom_field0," + else: + self_fields_list = ",".join(map(lambda x: "self._custom_field" + str(x), range(x))) + acc += type_template.format(c=x, self_fields_list=self_fields_list, max=x) + for y in range(x): + acc += get_field_by_idx_template.format(c=y) + + acc += set_field_prefix_template.format(max=x) + + for y in range(x): + acc += set_field_by_idx_template.format(c=y) + + + + #print acc + return acc + +exec gen_ct_class_code() + + +@as_var("create-type") +def create_type(type_name, fields): + affirm(isinstance(type_name, Keyword), u"Type name must be a keyword") + affirm(isinstance(fields, Array), u"Type names must be in an array") + assert isinstance(fields, Array) + acc = {} + + for i, val in enumerate(fields._list): + affirm(isinstance(val, Keyword), u"Field names must be keywords") + acc[val] = i + + from pixie.vm2.string import String + assert isinstance(type_name, Keyword) + return CustomType(type_name._str, acc) + +@as_var("new") +@jit.unroll_safe +def _new__args(args): + affirm(len(args) >= 1, u"new takes at least one parameter") + tp = args[0] + affirm(isinstance(tp, CustomType), u"Can only create a new instance of a custom type") + cnt = len(args) - 1 + affirm(cnt - 1 != tp.get_num_slots(), u"Wrong number of initializer fields to custom type") + arr = [None] * cnt + for x in range(cnt): + val = args[x + 1] + if isinstance(val, Integer): + val = IntegerMutableCell(val.int_val()) + elif isinstance(val, Float): + val = FloatMutableCell(val.float_val()) + + arr[x] = val + return new_inst(tp, arr) + +@as_var("set-field!") +def set_field(inst, field, val): + affirm(isinstance(inst, CustomTypeInstance), u"Can only set fields on CustomType instances") + affirm(isinstance(field, Keyword), u"Field must be a keyword") + inst.set_field(field, val) + return inst + +@as_var("get-field") +def get_field(inst, field): + affirm(isinstance(inst, CustomTypeInstance), u"Can only get fields on CustomType instances") + affirm(isinstance(field, Keyword), u"Field must be a keyword") + return inst.get_field(field) + + + +class AbstractMutableCell(Object): + _type = Type(u"pixie.stdlib.AbstractMutableCell") + def type(self): + return self._type + + def set_mutable_cell_value(self, ct, fields, nm, idx, value): + pass + + def get_mutable_cell_value(self): + pass + +class IntegerMutableCell(AbstractMutableCell): + def __init__(self, int_val): + self._mutable_integer_val = int_val + + def set_mutable_cell_value(self, ct, fields, nm, idx, value): + if not isinstance(value, Integer): + ct.set_mutable(nm) + if isinstance(value, Float): + fields.set_field_by_idx(idx, FloatMutableCell(value.float_val())) + else: + fields.set_field_by_idx(idx, value) + else: + self._mutable_integer_val = value.int_val() + + def get_mutable_cell_value(self): + return rt.wrap(self._mutable_integer_val) + +class FloatMutableCell(AbstractMutableCell): + def __init__(self, float_val): + self._mutable_float_val = float_val + + def set_mutable_cell_value(self, ct, fields, nm, idx, value): + if not isinstance(value, Float): + ct.set_mutable(nm) + if isinstance(value, Integer): + fields.set_field_by_idx(idx, IntegerMutableCell(value.int_val())) + else: + fields.set_field_by_idx(idx, value) + else: + self._mutable_float_val = value.float_val() + + def get_mutable_cell_value(self): + return rt.wrap(self._mutable_float_val) \ No newline at end of file diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index 7a7d6f49..5539f946 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -51,7 +51,6 @@ def wrapper(*args): import pixie.vm2.code as code import pixie.vm2.numbers as numbers import pixie.vm2.stdlib - #import pixie.vm.bits #import pixie.vm.interpreter #import pixie.vm.atom #import pixie.vm.reduced @@ -142,6 +141,9 @@ def int_val(x): numbers.init() code.init() + import pixie.vm2.bits + + def unwrap_string(x): from pixie.vm2.string import String diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py new file mode 100644 index 00000000..7dc112a6 --- /dev/null +++ b/pixie/vm2/stdlib.py @@ -0,0 +1,175 @@ +import pixie.vm2.rt as rt +from pixie.vm2.code import as_var, Var, list_copy, NativeFn +from pixie.vm2.object import affirm, Type, runtime_error +from pixie.vm2.primitives import nil, true, false +import pixie.vm2.code as code +import pixie.vm2.array as array +from rpython.rlib.rarithmetic import r_uint +import rpython.rlib.jit as jit + +@as_var("set-var-root!") +def _set_var_root(v, r): + assert isinstance(v, Var) + v.set_root(r) + return v + +@as_var("satisfy") +def satisfy(protocol, tp): + affirm(isinstance(protocol, code.Protocol), u"First argument must be a protocol") + affirm(isinstance(tp, Type), u"Second argument must be a type") + protocol.add_satisfies(tp) + return protocol + +@as_var("pixie.stdlib.internal", "-defprotocol") +def _defprotocol(name, methods): + from pixie.vm2.string import String + from pixie.vm2.symbol import Symbol + affirm(isinstance(name, String), u"protocol name must be a symbol") + affirm(isinstance(methods, array.Array), u"protocol methods must be an array of symbols") + assert isinstance(methods, array.Array) + method_list = [] + for method_sym in methods._list: + affirm(isinstance(method_sym, String), u"protocol methods must be a vector of symbols") + assert isinstance(method_sym, String) + method_list.append(method_sym._str) + + assert isinstance(name, String) + proto = code.Protocol(name._str) + name_sym = Symbol(name._str) + code.intern_var(name_sym.get_ns(), name_sym.get_name()).set_root(proto) + for method in method_list: + method = unicode(method) + poly = code.PolymorphicFn(method, proto) + code.intern_var(name_sym.get_ns(), method).set_root(poly) + + return name + + +@as_var("polymorphic-fn") +def polymorphic_fn(name, protocol): + from pixie.vm2.string import String + affirm(isinstance(name, String), u"polymorphic functions must have string names") + affirm(isinstance(protocol, code.Protocol), u"must be a protocol") + assert isinstance(name, String) + return code.PolymorphicFn(name._str, protocol) + + +@as_var("protocol") +def protocol(name): + from pixie.vm2.string import String + affirm(isinstance(name, String), u"Protocol names must be strings") + assert isinstance(name, String) + return code.Protocol(name._str) + +@as_var("extend") +def _extend(proto_fn, tp, fn): + if not isinstance(proto_fn, code.PolymorphicFn): + runtime_error(u"Fist argument to extend should be a PolymorphicFn not a " + proto_fn.type().name()) + + affirm(isinstance(tp, Type) or isinstance(tp, code.Protocol), u"Second argument to extend must be a Type or Protocol") + proto_fn.extend(tp, fn) + return nil + +@as_var("variadic-fn") +def _variadic_fn(required_arity, fn): + arity = required_arity.int_val() + return code.VariadicCode(required_arity=arity, code=fn) + +@as_var("multi-arity-fn") +def _multi_arity_fn__args(args): + from pixie.vm2.string import String + nm = args[0] + affirm(isinstance(nm, String), u"Function name must be string") + assert isinstance(nm, String) + arities = {} + + required_arity = 0 + rest_fn = None + + idx = 1 + while idx + 1 < len(args): + arity = args[idx].int_val() + if arity < 0: + required_arity = -arity + rest_fn = args[idx + 1] + else: + arities[arity] = args[idx + 1] + idx += 2 + + return code.MultiArityFn(nm._str, arities, required_arity, rest_fn) + +class Apply(NativeFn): + @jit.unroll_safe + def invoke_k(self, args, stack): + from pixie.vm2.array import Array + last_itm = args[len(args) - 1] + affirm(isinstance(last_itm, Array), u"Final argument in -apply must be an array") + assert isinstance(last_itm, Array) + fn = args[0] + argc = r_uint(len(args) - 2) + out_args = [None] * (argc + len(last_itm._list)) + + list_copy(args, 1, out_args, 0, argc) + + for x in range(len(last_itm._list)): + out_args[argc + x] = last_itm._list[x] + + return fn.invoke_k(out_args, stack) + +as_var("-apply")(Apply()) + + +@as_var("-satisfies?") +def _satisfies(proto, o): + affirm(isinstance(proto, code.Protocol), u"proto must be a Protocol") + + return true if proto.satisfies(o.type()) else false + + +@as_var("-instance?") +def _instance(c, o): + from pixie.vm2.object import istypeinstance + affirm(isinstance(c, Type), u"c must be a type") + + return true if istypeinstance(o.type(), c) else false + + +@as_var("-internal-get-field") +def _get_field(inst, k): + return inst.get_field(k) + +@as_var("identical?") +def identical(a, b): + return true if a is b else false + +@as_var("-internal-to-str") +def _internal_to_str(x): + return rt.wrap(x.to_str()) + +@as_var("-internal-to-repr") +def _internal_to_repr(x): + return rt.wrap(x.to_repr()) + +@as_var("-blocking-println") +def _blocking_println(x): + print rt.unwrap_string(x) + return x + + +@as_var("-string-builder") +def _string_builder(): + from pixie.vm2.string_builder import StringBuilder + return StringBuilder() + +@as_var("-add-to-string-builder") +def _add_to_string_builder(sb, x): + from pixie.vm2.string import String + if isinstance(x, String): + sb.add_str(x._str) + return sb + else: + runtime_error(u"Expected string or char", u"pixie.stdlib.IllegalArgumentException") + +@as_var("-finish-string-builder") +def _finish_string_builder(sb): + return rt.wrap(sb.to_str()) \ No newline at end of file diff --git a/pixie/vm2/string_builder.py b/pixie/vm2/string_builder.py new file mode 100644 index 00000000..299b283b --- /dev/null +++ b/pixie/vm2/string_builder.py @@ -0,0 +1,21 @@ +import pixie.vm2.rt as rt +from pixie.vm2.object import Object, Type +from pixie.vm2.code import as_var, extend +import pixie.vm2.stdlib as proto + +class StringBuilder(Object): + _type = Type(u"pixie.stdlib.StringBuilder") + + def type(self): + return StringBuilder._type + + def __init__(self): + self._strs = [] + + def add_str(self, s): + self._strs.append(s) + return self + + def to_str(self): + return u"".join(self._strs) + diff --git a/pixie/vm2/symbol.py b/pixie/vm2/symbol.py new file mode 100644 index 00000000..94e0586b --- /dev/null +++ b/pixie/vm2/symbol.py @@ -0,0 +1,103 @@ +import pixie.vm2.object as object +from pixie.vm2.primitives import nil, true, false +from pixie.vm2.code import extend, as_var +from pixie.vm2.string import String +import pixie.vm2.rt as rt +#import pixie.vm2.util as util +from rpython.rlib.rarithmetic import intmask + + +class Symbol(object.Object): + _type = object.Type(u"pixie.stdlib.Symbol") + def __init__(self, s, meta=nil): + #assert isinstance(s, unicode) + self._str = s + self._w_name = None + self._w_ns = None + self._hash = 0 + self._meta = meta + + def type(self): + return Symbol._type + + def init_names(self): + if self._w_name is None: + s = self._str.split(u"/") + if len(s) == 2: + self._w_ns = rt.wrap(s[0]) + self._w_name = rt.wrap(s[1]) + elif len(s) == 1: + self._w_name = rt.wrap(s[0]) + self._w_ns = nil + else: + self._w_ns = rt.wrap(s[0]) + self._w_name = rt.wrap(u"/".join(s[1:])) + + def with_meta(self, meta): + return Symbol(self._str, meta) + + def meta(self): + return self._meta + + def get_name(self): + self.init_names() + return rt.unwrap_string(self._w_name) + + def get_ns(self): + self.init_names() + return rt.unwrap_string(self._w_ns) + + + +def symbol(s): + return Symbol(s) +# +# @extend(proto._eq, Symbol) +# def _eq(self, other): +# assert isinstance(self, Symbol) +# if not isinstance(other, Symbol): +# return false +# return true if self._str == other._str else false +# +# @extend(proto._str, Symbol) +# def _str(self): +# assert isinstance(self, Symbol) +# return rt.wrap(self._str) +# +# @extend(proto._name, Symbol) +# def _name(self): +# assert isinstance(self, Symbol) +# self.init_names() +# return self._w_name +# +# @extend(proto._namespace, Symbol) +# def _namespace(self): +# assert isinstance(self, Symbol) +# self.init_names() +# return self._w_ns +# +# @extend(proto._hash, Symbol) +# def _hash(self): +# assert isinstance(self, Symbol) +# if self._hash == 0: +# self._hash = util.hash_unencoded_chars(self._str) +# return rt.wrap(intmask(self._hash)) +# +# @as_var("symbol") +# def _symbol(s): +# if not isinstance(s, String): +# from pixie.vm.object import runtime_error +# runtime_error(u"Symbol name must be a string") +# return symbol(s._str) +# +# +# +# @extend(proto._meta, Symbol) +# def _meta(self): +# assert isinstance(self, Symbol) +# return self.meta() +# +# @extend(proto._with_meta, Symbol) +# def _with_meta(self, meta): +# assert isinstance(self, Symbol) +# return self.with_meta(meta) From 5e5e369954e30b3f7189fd2e31f3b698b6c62673 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Thu, 21 May 2015 17:02:41 -0600 Subject: [PATCH 12/46] a bit of JIT work, added in-ns --- bootstrap.py | 4544 +++++++++++++++++++++++--------------- pixie/bootstrap.pxi | 200 +- pixie/compiler.pxi | 49 +- pixie/vm2/code.py | 58 +- pixie/vm2/interpreter.py | 72 +- pixie/vm2/numbers.py | 3 - pixie/vm2/object.py | 51 +- target2.py | 10 +- 8 files changed, 3082 insertions(+), 1905 deletions(-) diff --git a/bootstrap.py b/bootstrap.py index 834ed993..76ddc220 100755 --- a/bootstrap.py +++ b/bootstrap.py @@ -1,270 +1,342 @@ -mid0 = (u"""(defprotocol ISeq""", "", 4) -mid1 = (u"""(defprotocol ISeqable""", "", 8) -mid2 = (u"""(defprotocol ICounted""", "", 11) -mid3 = (u"""(defprotocol IIndexed""", "", 14) -mid4 = (u"""(defprotocol IPersistentCollection""", "", 19) -mid5 = (u"""(defprotocol IEmpty""", "", 23) -mid6 = (u"""(defprotocol IObject""", "", 26) -mid7 = (u"""(defprotocol IReduce""", "", 32) -mid8 = (u"""(defprotocol IDeref""", "", 35) -mid9 = (u"""(defprotocol IReset""", "", 38) -mid10 = (u"""(defprotocol INamed""", "", 41) -mid11 = (u"""(defprotocol IAssociative""", "", 45) -mid12 = (u"""(defprotocol ILookup""", "", 50) -mid13 = (u"""(defprotocol IMapEntry""", "", 53) -mid14 = (u"""(defprotocol IStack""", "", 57) -mid15 = (u"""(defprotocol IPop""", "", 60) -mid16 = (u"""(defprotocol IFn""", "", 63) -mid17 = (u"""(defprotocol IDoc""", "", 66) -mid18 = (u"""(defprotocol IMeta""", "", 73) -mid19 = (u"""(defprotocol ITransientCollection""", "", 77) -mid20 = (u"""(defprotocol IToTransient""", "", 80) -mid21 = (u"""(defprotocol ITransientStack""", "", 83) -mid22 = (u"""(defprotocol IDisposable""", "", 87) -mid23 = (u"""(defprotocol IMessageObject""", "", 90) -mid24 = (u"""(extend -get-field Object -internal-get-field)""", "", 96) -mid25 = (u"""(extend -str Object (fn [x sb]""", "", 97) -mid26 = (u""" (sb (-internal-to-str x))))""", "", 98) -mid27 = (u"""(extend -repr Object (fn [x sb]""", "", 99) -mid28 = (u""" (sb (-internal-to-repr x))))""", "", 100) -mid29 = (u""" (-str [this sb]""", "", 105) -mid30 = (u"""(extend-type String""", "", 103) -mid31 = (u""" (sb this)))""", "", 106) -mid32 = (u"""(extend -eq Number -num-eq)""", "", 110) -mid33 = (u""" ([x] x)""", "", 117) -mid34 = (u""" ([x y] (-add x y))""", "", 118) -mid35 = (u""" (-apply + (+ x y) more)))""", "", 120) -mid36 = (u""" ([x] x)""", "", 124) -mid37 = (u""" ([x y] (-sub x y))""", "", 125) -mid38 = (u""" (-apply - (- x y) more))) """, "", 127) -mid39 = (u""" ([x] (+ x 1)))""", "", 130) -mid40 = (u""" ([x] (- x 1)))""", "", 133) -mid41 = (u""" ([x y] (-lt x y))""", "", 136) -mid42 = (u""" (-apply < (< x y) more)))""", "", 138) -mid43 = (u""" ([x y] (-gt x y))""", "", 141) -mid44 = (u""" (-apply > (> x y) more)))""", "", 143) -mid45 = (u""" ([x y] (if (identical? x y)""", "", 151) -mid46 = (u""" (-eq x y)))""", "", 153) -mid47 = (u""" ([x y & rest] (if (eq x y)""", "", 154) -mid48 = (u""" (apply = y rest)""", "", 155) -mid49 = (u""" ([coll] coll)""", "", 160) -mid50 = (u""" ([coll itm] (-conj coll itm))""", "", 161) -mid51 = (u""" (-apply conj (conj x y) more)))""", "", 163) -mid52 = (u""" ([coll] (-count coll)))""", "", 167) -mid53 = (u"""(deftype Cons [first next meta]""", "", 170) -mid54 = (u""" (-first [this] first)""", "", 172) -mid55 = (u""" (-next [this] next)""", "", 173) -mid56 = (u""" (-seq [this] this)""", "", 175) -mid57 = (u""" (-meta [this] meta)""", "", 177) -mid58 = (u""" (-with-meta [this new-meta]""", "", 178) -mid59 = (u""" (->Cons first next new-meta)))""", "", 179) -mid60 = (u""" (->Cons head (seq tail) nil))""", "", 182) -mid61 = (u""" ([] (-string-builder))""", "", 187) -mid62 = (u""" ([sb] (-str sb))""", "", 188) -mid63 = (u""" (if (instance? String x)""", "", 190) -mid64 = (u""" (-add-to-string-builder x)""", "", 191) -mid65 = (u""" (-add-to-string-bulder (-str x)))))""", "", 192) -mid66 = (u""" (transduce""", "", 195) -mid67 = (u""" (map str)""", "", 196) -mid68 = (u""" string-builder""", "", 197) -mid69 = (u""" args))""", "", 198) -mid70 = (u""" (let [sb (-string-builder)""", "", 201) -mid71 = (u""" (-add-to-string-builder sb x))]""", "", 203) -mid72 = (u""" sb sb]""", "", 205) -mid73 = (u""" (loop [idx 0""", "", 204) -mid74 = (u""" (if (< idx (count args))""", "", 206) -mid75 = (u""" (recur (inc idx)""", "", 207) -mid76 = (u""" (do (-str (aget args idx) add-fn)""", "", 208) -mid77 = (u""" (add-fn " ")""", "", 209) -mid78 = (u""" sb))""", "", 210) -mid79 = (u""" (-blocking-println (-finish-string-builder sb))))""", "", 211) -mid80 = (u""" (if (-satisfies? ISeqable t)""", "", 225) -mid81 = (u""" (let [ts (seq t)]""", "", 226) -mid82 = (u""" (if (not ts) false""", "", 227) -mid83 = (u""" (if (-instance? (first ts) x)""", "", 228) -mid84 = (u""" (instance? (rest ts) x))))""", "", 230) -mid85 = (u""" (-instance? t x)))""", "", 231) -mid86 = (u"""(deftype Reduced [x]""", "", 237) -mid87 = (u""" (-deref [this] x))""", "", 239) -mid88 = (u""" (->Reduced x))""", "", 242) -mid89 = (u""" (instance? Reduced x))""", "", 245) -mid90 = (u""" (if (-satisfies? ISeqable p)""", "", 258) -mid91 = (u""" (let [ps (seq p)]""", "", 259) -mid92 = (u""" (if (not ps) true""", "", 260) -mid93 = (u""" (if (not (-satisfies? (first ps) x))""", "", 261) -mid94 = (u""" (satisfies? (rest ps) x))))""", "", 263) -mid95 = (u""" (-satisfies? p x)))""", "", 264) -mid96 = (u""" (let [f (xform rf)""", "", 275) -mid97 = (u""" result (-reduce coll f (f))]""", "", 276) -mid98 = (u""" (f result)))""", "", 277) -mid99 = (u""" (let [result (-reduce coll f (f))]""", "", 272) -mid100 = (u""" (f result)))""", "", 273) -mid101 = (u""" (let [f (xform rf)""", "", 279) -mid102 = (u""" result (-reduce coll f init)]""", "", 280) -mid103 = (u""" (f result))))""", "", 281) -mid104 = (u""" (-reduce col rf init)))""", "", 287) -mid105 = (u""" (reduce rf (rf) col))""", "", 285) -mid106 = (u""" (if (satisfies? IToTransient to)""", "", 298) -mid107 = (u""" (transduce xform conj! (transient to) from)""", "", 299) -mid108 = (u""" (transduce xform conj to from))))""", "", 300) -mid109 = (u""" (if (satisfies? IToTransient to)""", "", 294) -mid110 = (u""" (persistent! (reduce conj! (transient to) from))""", "", 295) -mid111 = (u""" (reduce conj to from)))""", "", 296) -mid112 = (u""" ([] (xf))""", "", 309) -mid113 = (u""" ([result] (xf result))""", "", 310) -mid114 = (u""" ([result item] (xf result (f item))))))""", "", 311) -mid115 = (u""" (lazy-seq*""", "", 313) -mid116 = (u""" (let [s (seq coll)]""", "", 315) -mid117 = (u""" (if s""", "", 316) -mid118 = (u""" (cons (f (first s))""", "", 317) -mid119 = (u""" (map f (rest s)))""", "", 318) -mid120 = (u""" (lazy-seq*""", "", 322) -mid121 = (u""" (let [ss (map seq cs)]""", "", 324) -mid122 = (u""" (if (every? identity ss)""", "", 325) -mid123 = (u""" (cons (map first ss) (step (map rest ss)))""", "", 326) -mid124 = (u""" (map (fn [args] (apply f args)) (step colls)))))""", "", 328) -mid125 = (u""" (let [step (fn step [cs]""", "", 321) -mid126 = (u"""(deftype Range [start stop step]""", "", 334) -mid127 = (u""" (-reduce [self f init]""", "", 336) -mid128 = (u""" acc init]""", "", 338) -mid129 = (u""" (loop [i start""", "", 337) -mid130 = (u""" (println i)""", "", 339) -mid131 = (u""" (println acc)""", "", 340) -mid132 = (u""" (if (or (and (> step 0) (< i stop))""", "", 341) -mid133 = (u""" (and (< step 0) (> i stop))""", "", 342) -mid134 = (u""" (and (= step 0)))""", "", 343) -mid135 = (u""" (let [acc (f acc i)]""", "", 344) -mid136 = (u""" (if (reduced? acc)""", "", 345) -mid137 = (u""" @acc""", "", 346) -mid138 = (u""" (recur (+ i step) acc)))""", "", 347) -mid139 = (u""" acc)))""", "", 348) -mid140 = (u""" (-count [self]""", "", 350) -mid141 = (u""" (if (or (and (< start stop) (< step 0))""", "", 351) -mid142 = (u""" (and (> start stop) (> step 0))""", "", 352) -mid143 = (u""" (= step 0))""", "", 353) -mid144 = (u""" (abs (quot (- start stop) step))))""", "", 355) -mid145 = (u""" (-nth [self idx]""", "", 357) -mid146 = (u""" (when (or (= start stop 0) (neg? idx))""", "", 358) -mid147 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))""", "", 359) -mid148 = (u""" (let [cmp (if (< start stop) < >)""", "", 360) -mid149 = (u""" val (+ start (* idx step))]""", "", 361) -mid150 = (u""" (if (cmp val stop)""", "", 362) -mid151 = (u""" val""", "", 363) -mid152 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))))""", "", 364) -mid153 = (u""" (-nth-not-found [self idx not-found]""", "", 365) -mid154 = (u""" (let [cmp (if (< start stop) < >)""", "", 366) -mid155 = (u""" val (+ start (* idx step))]""", "", 367) -mid156 = (u""" (if (cmp val stop)""", "", 368) -mid157 = (u""" val""", "", 369) -mid158 = (u""" not-found)))""", "", 370) -mid159 = (u""" (-seq [self]""", "", 372) -mid160 = (u""" (when (or (and (> step 0) (< start stop))""", "", 373) -mid161 = (u""" (and (< step 0) (> start stop)))""", "", 374) -mid162 = (u""" (cons start (lazy-seq* #(range (+ start step) stop step)))))""", "", 375) -mid163 = (u""" (-str [this sbf]""", "", 377) -mid164 = (u""" (-str (seq this) sbf))""", "", 378) -mid165 = (u""" (-repr [this sbf]""", "", 379) -mid166 = (u""" (-repr (seq this) sbf))""", "", 380) -mid167 = (u""" (-eq [this sb]))""", "", 381) -mid168 = (u""" (analyze-form (cons 'do body))))""", "pixie/compiler.pxi", 259) -mid169 = (u""" ([] (->Range 0 MAX-NUMBER 1))""", "", 393) -mid170 = (u""" ([stop] (->Range 0 stop 1))""", "", 394) -mid171 = (u""" ([start stop step] (->Range start stop step)))""", "", 396) -mid172 = (u""" ([start stop] (->Range start stop 1))""", "", 395) -mid173 = (u"""(deftype Node [edit array]""", "", 402) -mid174 = (u""" (-get-field [this name]""", "", 404) -mid175 = (u""" (get-field this name)))""", "", 405) -mid176 = (u""" (new-node edit (array 32)))""", "", 409) -mid177 = (u""" (->Node edit array)))""", "", 411) -mid178 = (u"""(def EMPTY-NODE (new-node nil))""", "", 413) -mid179 = (u""" (let [cnt (.-cnt this)]""", "", 418) -mid180 = (u""" (if (< cnt 32)""", "", 419) -mid181 = (u""" (bit-shift-left (bit-shift-right (dec cnt) 5) 5))))""", "", 421) -mid182 = (u""" (if (and (<= 0 i) (< i cnt))""", "", 424) -mid183 = (u""" (if (>= i (tailoff this))""", "", 425) -mid184 = (u""" tail""", "", 426) -mid185 = (u""" (if (> level 0)""", "", 428) -mid186 = (u""" (look-deeper (aget (:array node)""", "", 429) -mid187 = (u""" (bit-and (bit-shift-right i level) 0x01f))""", "", 430) -mid188 = (u""" (- level 5))""", "", 431) -mid189 = (u""" (:array node)))""", "", 432) -mid190 = (u""" root""", "", 433) -mid191 = (u""" shift)))))""", "", 434) -mid192 = (u""" (.-array ((fn look-deeper [node level]""", "", 427) -mid193 = (u"""(deftype PersistentVector [cnt shift root tail meta]""", "", 436) -mid194 = (u""" (-get-field [this name]""", "", 438) -mid195 = (u""" (get-field this name))""", "", 439) -mid196 = (u""" (-conj [this val]""", "", 442) -mid197 = (u""" (assert (< cnt 0xFFFFFFFF) "Vector too large")""", "", 443) -mid198 = (u""" (if (< (- cnt (tailoff this)) 32)""", "", 445) -mid199 = (u""" (let [new-tail (array-append tail val)]""", "", 446) -mid200 = (u""" (->PersistentVector (inc cnt) shift root new-tail meta))""", "", 447) -mid201 = (u""" (let [tail-node (->Node (.-edit root) tail)]""", "", 449) -mid202 = (u""" (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift))""", "", 450) -mid203 = (u""" (let [new-root (new-node (.-edit root))]""", "", 452) -mid204 = (u""" (aset new-root 0 root)""", "", 453) -mid205 = (u""" (aset new-root 1 (new-path (.-edit root) shift tail-node))""", "", 454) -mid206 = (u""" (->PersistentVector (inc cnt)""", "", 455) -mid207 = (u""" (+ shift 5)""", "", 456) -mid208 = (u""" new-root""", "", 457) -mid209 = (u""" (array val)""", "", 458) -mid210 = (u""" (let [new-root (push-tail this shift root tail-node)]""", "", 460) -mid211 = (u""" (->PersistentVector (inc cnt)""", "", 461) -mid212 = (u""" new-root""", "", 463) -mid213 = (u""" (array val)""", "", 464) -mid214 = (u""" (-count [this] cnt))""", "", 468) -mid215 = (u""" (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f)""", "", 472) -mid216 = (u""" ret-array (array-clone (.-array parent))""", "", 473) -mid217 = (u""" node-to-insert (if (= level 5)""", "", 474) -mid218 = (u""" tail-node""", "", 475) -mid219 = (u""" (let [child (aget (.-array parent) subidx)]""", "", 476) -mid220 = (u""" (if (= child nil)""", "", 477) -mid221 = (u""" (new-path (.-edit (.-root this))""", "", 478) -mid222 = (u""" (- level 5)""", "", 479) -mid223 = (u""" tail-node)""", "", 480) -mid224 = (u""" (push-tail this""", "", 481) -mid225 = (u""" (- level 5)""", "", 482) -mid226 = (u""" child""", "", 483) -mid227 = (u""" tail-node))))]""", "", 484) -mid228 = (u""" (aset ret-array subidx node-to-insert)""", "", 485) -mid229 = (u""" (->Node (.-edit parent) node-to-insert)))""", "", 486) -mid230 = (u""" (if (= level 0)""", "", 489) -mid231 = (u""" node""", "", 490) -mid232 = (u""" (->Node edit""", "", 491) -mid233 = (u""" (new-path edit (- level 5) node))))""", "", 492) -mid234 = (u"""(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil))""", "", 495) -mid235 = (u""" (println "Vector for array")""", "", 498) -mid236 = (u""" (println (count arr))""", "", 499) -mid237 = (u""" (if (< (count arr) 32)""", "", 500) -mid238 = (u""" (->PersistentVector (count arr) 5 EMPTY-NODE arr nil)""", "", 501) -mid239 = (u""" (into [] arr)))""", "", 502) -mid240 = (u""" (-reduce [this f init]""", "", 516) -mid241 = (u"""(extend-type Array""", "", 506) -mid242 = (u""" acc init]""", "", 518) -mid243 = (u""" (loop [idx 0""", "", 517) -mid244 = (u""" (if (reduced? acc)""", "", 519) -mid245 = (u""" @acc""", "", 520) -mid246 = (u""" (if (< idx (count this))""", "", 521) -mid247 = (u""" (recur (inc idx)""", "", 522) -mid248 = (u""" (f acc (aget this idx)))""", "", 523) -mid249 = (u""" acc)))))""", "", 524) -mid250 = (u""" (-count ([arr]""", "", 512) -mid251 = (u""" (.-count arr)))""", "", 513) -mid252 = (u""" (-conj [arr itm]""", "", 508) -mid253 = (u""" (conj (vector-from-array arr) itm))""", "", 509) -mid254 = (u""" (loop [idx 0]""", "", 527) -mid255 = (u""" (when (< idx size)""", "", 528) -mid256 = (u""" (do (aset to (+ to-idx idx) (aget from (+ from-idx idx)))""", "", 529) -mid257 = (u""" (recur (inc idx))))))""", "", 530) -mid258 = (u""" (let [new-array (make-array (inc (count arr)))]""", "", 533) -mid259 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 534) -mid260 = (u""" (aset new-array (count arr) val)""", "", 535) -mid261 = (u""" new-array))""", "", 536) -mid262 = (u""" (let [new-array (make-array (count arr))]""", "", 539) -mid263 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 540) -mid264 = (u""" new-array))""", "", 541) -mid265 = (u"""(into [] (range 40))""", "", 545) -mid266 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) +mid0 = (u""" `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm)))""", "pixie/compiler.pxi", 10) +mid1 = (u""" `(def ~x (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))""", "pixie/compiler.pxi", 12) +mid2 = (u"""(defprotocol ISeq""", "", 4) +mid3 = (u"""(defprotocol ISeqable""", "", 8) +mid4 = (u"""(defprotocol ICounted""", "", 11) +mid5 = (u"""(defprotocol IIndexed""", "", 14) +mid6 = (u"""(defprotocol IPersistentCollection""", "", 19) +mid7 = (u"""(defprotocol IEmpty""", "", 23) +mid8 = (u"""(defprotocol IObject""", "", 26) +mid9 = (u"""(defprotocol IReduce""", "", 32) +mid10 = (u"""(defprotocol IDeref""", "", 35) +mid11 = (u"""(defprotocol IReset""", "", 38) +mid12 = (u"""(defprotocol INamed""", "", 41) +mid13 = (u"""(defprotocol IAssociative""", "", 45) +mid14 = (u"""(defprotocol ILookup""", "", 50) +mid15 = (u"""(defprotocol IMapEntry""", "", 53) +mid16 = (u"""(defprotocol IStack""", "", 57) +mid17 = (u"""(defprotocol IPop""", "", 60) +mid18 = (u"""(defprotocol IFn""", "", 63) +mid19 = (u"""(defprotocol IDoc""", "", 66) +mid20 = (u"""(defprotocol IMeta""", "", 73) +mid21 = (u"""(defprotocol ITransientCollection""", "", 77) +mid22 = (u"""(defprotocol IToTransient""", "", 80) +mid23 = (u"""(defprotocol ITransientStack""", "", 83) +mid24 = (u"""(defprotocol IDisposable""", "", 87) +mid25 = (u"""(defprotocol IMessageObject""", "", 90) +mid26 = (u"""(extend -get-field Object -internal-get-field)""", "", 96) +mid27 = (u""" (-eq [this other]""", "", 106) +mid28 = (u"""(extend-type Object""", "", 99) +mid29 = (u""" (-repr [x sb]""", "", 103) +mid30 = (u""" (sb (-internal-to-repr x)))""", "", 104) +mid31 = (u""" (-str [x sb]""", "", 100) +mid32 = (u""" (sb (-internal-to-str x)))""", "", 101) +mid33 = (u""" (-str [this sb]""", "", 111) +mid34 = (u"""(extend-type String""", "", 109) +mid35 = (u""" (sb this)))""", "", 112) +mid36 = (u"""(extend -eq Number -num-eq)""", "", 116) +mid37 = (u""" ([x] x)""", "", 123) +mid38 = (u""" ([x y] (-add x y))""", "", 124) +mid39 = (u""" (-apply + (+ x y) more)))""", "", 126) +mid40 = (u""" ([x] x)""", "", 130) +mid41 = (u""" ([x y] (-sub x y))""", "", 131) +mid42 = (u""" (-apply - (- x y) more))) """, "", 133) +mid43 = (u""" ([x] (+ x 1)))""", "", 136) +mid44 = (u""" ([x] (- x 1)))""", "", 139) +mid45 = (u""" ([x y] (-lt x y))""", "", 142) +mid46 = (u""" (-apply < (< x y) more)))""", "", 144) +mid47 = (u""" ([x y] (-gt x y))""", "", 147) +mid48 = (u""" (-apply > (> x y) more)))""", "", 149) +mid49 = (u""" ([x y] (-lte x y))""", "", 154) +mid50 = (u""" ([x y & rest] (if (-lte x y)""", "", 155) +mid51 = (u""" (apply <= y rest)""", "", 156) +mid52 = (u""" ([x y] (-gte x y))""", "", 161) +mid53 = (u""" ([x y & rest] (if (-gte x y)""", "", 162) +mid54 = (u""" (apply >= y rest)""", "", 163) +mid55 = (u""" ([x y] (if (identical? x y)""", "", 173) +mid56 = (u""" (-eq x y)))""", "", 175) +mid57 = (u""" ([x y & rest] (if (eq x y)""", "", 176) +mid58 = (u""" (apply = y rest)""", "", 177) +mid59 = (u""" ([coll] coll)""", "", 182) +mid60 = (u""" ([coll itm] (-conj coll itm))""", "", 183) +mid61 = (u""" (-apply conj (conj x y) more)))""", "", 185) +mid62 = (u""" ([coll idx not-found] (-nth-not-found coll idx not-found)))""", "", 194) +mid63 = (u""" ([coll idx] (-nth coll idx))""", "", 193) +mid64 = (u""" ([coll] (-count coll)))""", "", 198) +mid65 = (u"""(deftype Cons [first next meta]""", "", 201) +mid66 = (u""" (-first [this] first)""", "", 203) +mid67 = (u""" (-next [this] next)""", "", 204) +mid68 = (u""" (-seq [this] this)""", "", 206) +mid69 = (u""" (-meta [this] meta)""", "", 208) +mid70 = (u""" (-with-meta [this new-meta]""", "", 209) +mid71 = (u""" (->Cons first next new-meta)))""", "", 210) +mid72 = (u""" (->Cons head (seq tail) nil))""", "", 213) +mid73 = (u""" ([] (-string-builder))""", "", 218) +mid74 = (u""" ([sb] (-str sb))""", "", 219) +mid75 = (u""" (if (instance? String x)""", "", 221) +mid76 = (u""" (-add-to-string-builder x)""", "", 222) +mid77 = (u""" (-add-to-string-bulder (-str x)))))""", "", 223) +mid78 = (u""" (transduce""", "", 226) +mid79 = (u""" (map str)""", "", 227) +mid80 = (u""" string-builder""", "", 228) +mid81 = (u""" args))""", "", 229) +mid82 = (u""" (let [sb (-string-builder)""", "", 232) +mid83 = (u""" (-add-to-string-builder sb x))]""", "", 234) +mid84 = (u""" sb sb]""", "", 236) +mid85 = (u""" (loop [idx 0""", "", 235) +mid86 = (u""" (if (< idx (count args))""", "", 237) +mid87 = (u""" (recur (inc idx)""", "", 238) +mid88 = (u""" (do (-str (aget args idx) add-fn)""", "", 239) +mid89 = (u""" (add-fn " ")""", "", 240) +mid90 = (u""" sb))""", "", 241) +mid91 = (u""" (-blocking-println (-finish-string-builder sb))))""", "", 242) +mid92 = (u""" (if (-satisfies? ISeqable t)""", "", 256) +mid93 = (u""" (let [ts (seq t)]""", "", 257) +mid94 = (u""" (if (not ts) false""", "", 258) +mid95 = (u""" (if (-instance? (first ts) x)""", "", 259) +mid96 = (u""" (instance? (rest ts) x))))""", "", 261) +mid97 = (u""" (-instance? t x)))""", "", 262) +mid98 = (u"""(deftype Reduced [x]""", "", 268) +mid99 = (u""" (-deref [this] x))""", "", 270) +mid100 = (u""" (->Reduced x))""", "", 273) +mid101 = (u""" (instance? Reduced x))""", "", 276) +mid102 = (u""" (if (-satisfies? ISeqable p)""", "", 289) +mid103 = (u""" (let [ps (seq p)]""", "", 290) +mid104 = (u""" (if (not ps) true""", "", 291) +mid105 = (u""" (if (not (-satisfies? (first ps) x))""", "", 292) +mid106 = (u""" (satisfies? (rest ps) x))))""", "", 294) +mid107 = (u""" (-satisfies? p x)))""", "", 295) +mid108 = (u""" (let [f (xform rf)""", "", 306) +mid109 = (u""" result (-reduce coll f (f))]""", "", 307) +mid110 = (u""" (f result)))""", "", 308) +mid111 = (u""" (let [result (-reduce coll f (f))]""", "", 303) +mid112 = (u""" (f result)))""", "", 304) +mid113 = (u""" (let [f (xform rf)""", "", 310) +mid114 = (u""" result (-reduce coll f init)]""", "", 311) +mid115 = (u""" (f result))))""", "", 312) +mid116 = (u""" (-reduce col rf init)))""", "", 318) +mid117 = (u""" (reduce rf (rf) col))""", "", 316) +mid118 = (u""" (if (satisfies? IToTransient to)""", "", 329) +mid119 = (u""" (transduce xform conj! (transient to) from)""", "", 330) +mid120 = (u""" (transduce xform conj to from))))""", "", 331) +mid121 = (u""" (if (satisfies? IToTransient to)""", "", 325) +mid122 = (u""" (persistent! (reduce conj! (transient to) from))""", "", 326) +mid123 = (u""" (reduce conj to from)))""", "", 327) +mid124 = (u""" ([] (xf))""", "", 340) +mid125 = (u""" ([result] (xf result))""", "", 341) +mid126 = (u""" ([result item] (xf result (f item))))))""", "", 342) +mid127 = (u""" (lazy-seq*""", "", 344) +mid128 = (u""" (let [s (seq coll)]""", "", 346) +mid129 = (u""" (if s""", "", 347) +mid130 = (u""" (cons (f (first s))""", "", 348) +mid131 = (u""" (map f (rest s)))""", "", 349) +mid132 = (u""" (lazy-seq*""", "", 353) +mid133 = (u""" (let [ss (map seq cs)]""", "", 355) +mid134 = (u""" (if (every? identity ss)""", "", 356) +mid135 = (u""" (cons (map first ss) (step (map rest ss)))""", "", 357) +mid136 = (u""" (map (fn [args] (apply f args)) (step colls)))))""", "", 359) +mid137 = (u""" (let [step (fn step [cs]""", "", 352) +mid138 = (u"""(deftype Range [start stop step]""", "", 367) +mid139 = (u""" (-reduce [self f init]""", "", 369) +mid140 = (u""" acc init]""", "", 371) +mid141 = (u""" (loop [i start""", "", 370) +mid142 = (u""" (if (or (and (> step 0) (< i stop))""", "", 372) +mid143 = (u""" (and (< step 0) (> i stop))""", "", 373) +mid144 = (u""" (and (= step 0)))""", "", 374) +mid145 = (u""" (let [acc (f acc i)]""", "", 375) +mid146 = (u""" (if (reduced? acc)""", "", 376) +mid147 = (u""" @acc""", "", 377) +mid148 = (u""" (recur (+ i step) acc)))""", "", 378) +mid149 = (u""" acc)))""", "", 379) +mid150 = (u""" (-count [self]""", "", 381) +mid151 = (u""" (if (or (and (< start stop) (< step 0))""", "", 382) +mid152 = (u""" (and (> start stop) (> step 0))""", "", 383) +mid153 = (u""" (= step 0))""", "", 384) +mid154 = (u""" (abs (quot (- start stop) step))))""", "", 386) +mid155 = (u""" (-nth [self idx]""", "", 388) +mid156 = (u""" (when (or (= start stop 0) (neg? idx))""", "", 389) +mid157 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))""", "", 390) +mid158 = (u""" (let [cmp (if (< start stop) < >)""", "", 391) +mid159 = (u""" val (+ start (* idx step))]""", "", 392) +mid160 = (u""" (if (cmp val stop)""", "", 393) +mid161 = (u""" val""", "", 394) +mid162 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))))""", "", 395) +mid163 = (u""" (-nth-not-found [self idx not-found]""", "", 396) +mid164 = (u""" (let [cmp (if (< start stop) < >)""", "", 397) +mid165 = (u""" val (+ start (* idx step))]""", "", 398) +mid166 = (u""" (if (cmp val stop)""", "", 399) +mid167 = (u""" val""", "", 400) +mid168 = (u""" not-found)))""", "", 401) +mid169 = (u""" (-seq [self]""", "", 403) +mid170 = (u""" (when (or (and (> step 0) (< start stop))""", "", 404) +mid171 = (u""" (and (< step 0) (> start stop)))""", "", 405) +mid172 = (u""" (cons start (lazy-seq* #(range (+ start step) stop step)))))""", "", 406) +mid173 = (u""" (-str [this sbf]""", "", 408) +mid174 = (u""" (-str (seq this) sbf))""", "", 409) +mid175 = (u""" (-repr [this sbf]""", "", 410) +mid176 = (u""" (-repr (seq this) sbf))""", "", 411) +mid177 = (u""" (-eq [this sb]""", "", 412) +mid178 = (u""" ([] (pixie.stdlib.range/->Range 0 MAX-NUMBER 1))""", "", 427) +mid179 = (u""" ([stop] (pixie.stdlib.range/->Range 0 stop 1))""", "", 428) +mid180 = (u""" ([start stop step] (pixie.stdlib.range/->Range start stop step)))""", "", 430) +mid181 = (u""" ([start stop] (pixie.stdlib.range/->Range start stop 1))""", "", 429) +mid182 = (u"""(deftype Node [edit array]""", "", 436) +mid183 = (u""" (-get-field [this name]""", "", 438) +mid184 = (u""" (get-field this name)))""", "", 439) +mid185 = (u""" (new-node edit (make-array 32)))""", "", 443) +mid186 = (u""" (->Node edit array)))""", "", 445) +mid187 = (u"""(def EMPTY-NODE (new-node nil))""", "", 447) +mid188 = (u""" (analyze-form (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw)""", "pixie/compiler.pxi", 307) +mid189 = (u""" (let [cnt (.-cnt this)]""", "", 452) +mid190 = (u""" (if (< cnt 32)""", "", 453) +mid191 = (u""" (bit-shift-left (bit-shift-right (dec cnt) 5) 5))))""", "", 455) +mid192 = (u""" (if (and (<= 0 i) (< i (.-cnt this)))""", "", 458) +mid193 = (u""" (if (>= i (tailoff this))""", "", 459) +mid194 = (u""" (.-tail this)""", "", 460) +mid195 = (u""" (loop [node (.-root this)""", "", 461) +mid196 = (u""" level (.-shift this)]""", "", 462) +mid197 = (u""" (if (> level 0)""", "", 463) +mid198 = (u""" (recur (aget (.-array node)""", "", 464) +mid199 = (u""" (bit-and (bit-shift-right i level) 0x01f))""", "", 465) +mid200 = (u""" (- level 5))""", "", 466) +mid201 = (u""" (.-array node))))""", "", 467) +mid202 = (u""" (throw [:pixie.stdlib/IndexOutOfRangeException""", "", 468) +mid203 = (u"""(deftype PersistentVector [cnt shift root tail meta]""", "", 471) +mid204 = (u""" (-get-field [this name]""", "", 473) +mid205 = (u""" (get-field this name))""", "", 474) +mid206 = (u""" (-conj [this val]""", "", 477) +mid207 = (u""" (assert (< cnt 0xFFFFFFFF) "Vector too large")""", "", 478) +mid208 = (u""" (if (< (- cnt (tailoff this)) 32)""", "", 480) +mid209 = (u""" (let [new-tail (array-append tail val)]""", "", 481) +mid210 = (u""" (->PersistentVector (inc cnt) shift root new-tail meta))""", "", 482) +mid211 = (u""" (let [tail-node (->Node (.-edit root) tail)]""", "", 484) +mid212 = (u""" (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift))""", "", 485) +mid213 = (u""" (let [new-root (new-node (.-edit root))""", "", 487) +mid214 = (u""" new-root-arr (.-array new-root)]""", "", 488) +mid215 = (u""" (aset new-root-arr 0 root)""", "", 489) +mid216 = (u""" (aset new-root-arr 1 (new-path (.-edit root) shift tail-node))""", "", 490) +mid217 = (u""" (->PersistentVector (inc cnt)""", "", 491) +mid218 = (u""" (+ shift 5)""", "", 492) +mid219 = (u""" new-root""", "", 493) +mid220 = (u""" (array val)""", "", 494) +mid221 = (u""" (let [new-root (push-tail this shift root tail-node)]""", "", 496) +mid222 = (u""" (->PersistentVector (inc cnt)""", "", 497) +mid223 = (u""" new-root""", "", 499) +mid224 = (u""" (array val)""", "", 500) +mid225 = (u""" (-nth [self i]""", "", 503) +mid226 = (u""" (if (and (<= 0 i)""", "", 504) +mid227 = (u""" (< i cnt))""", "", 505) +mid228 = (u""" (let [node (array-for self i)]""", "", 506) +mid229 = (u""" (aget node (bit-and i 0x01F)))""", "", 507) +mid230 = (u""" (throw [:pixie.stdlib/IndexOutOfRange""", "", 508) +mid231 = (u""" (str "Index out of range, got " i " only have " cnt)])))""", "", 509) +mid232 = (u""" (-nth-not-found [self i not-found]""", "", 511) +mid233 = (u""" (if (and (<= 0 i)""", "", 512) +mid234 = (u""" (< i cnt))""", "", 513) +mid235 = (u""" (let [node (array-for self i)]""", "", 514) +mid236 = (u""" (aget node (bit-and i 0x01F)))""", "", 515) +mid237 = (u""" not-found))""", "", 516) +mid238 = (u""" (-get [this val]""", "", 521) +mid239 = (u""" (-nth-not-found self val nil))""", "", 522) +mid240 = (u""" (-count [this] cnt)""", "", 526) +mid241 = (u""" (-pop [this]""", "", 529) +mid242 = (u""" (assert (!= cnt) "Can't pop an empty vector")""", "", 530) +mid243 = (u""" (if (== cnt 1)""", "", 532) +mid244 = (u""" EMPTY""", "", 533) +mid245 = (u""" (if (> (- cnt (tailoff this)) 1)""", "", 534) +mid246 = (u""" (let [size (dec (count tail))""", "", 535) +mid247 = (u""" new-tail (array-resize size)]""", "", 536) +mid248 = (u""" (->PersistentVector (dec cnt)""", "", 537) +mid249 = (u""" new-tail""", "", 540) +mid250 = (u""" (let [new-tail (array-for this (- cnt 2))""", "", 542) +mid251 = (u""" new-root (pop-tail shift root)]""", "", 543) +mid252 = (u""" (nil? new-root)""", "", 545) +mid253 = (u""" (->PersisentVector (dec cnt)""", "", 546) +mid254 = (u""" EMPTY-NODE""", "", 548) +mid255 = (u""" new-tail""", "", 549) +mid256 = (u""" (and (> shift 5)""", "", 551) +mid257 = (u""" (nil? (aget (.-array new-root) 1)))""", "", 552) +mid258 = (u""" (->PersistentVector (dec cnt)""", "", 553) +mid259 = (u""" (- shift 5)""", "", 554) +mid260 = (u""" (aget (.-array new-root) 0)""", "", 555) +mid261 = (u""" new-tail""", "", 556) +mid262 = (u""" (->PersistentVector (dec cnt)""", "", 560) +mid263 = (u""" new-root""", "", 562) +mid264 = (u""" new-tail""", "", 563) +mid265 = (u""" (cond""", "", 544) +mid266 = (u""" (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f)""", "", 568) +mid267 = (u""" ret-array (array-clone (.-array parent))""", "", 569) +mid268 = (u""" node-to-insert (if (= level 5)""", "", 570) +mid269 = (u""" tail-node""", "", 571) +mid270 = (u""" (let [child (aget (.-array parent) subidx)]""", "", 572) +mid271 = (u""" (if (= child nil)""", "", 573) +mid272 = (u""" (new-path (.-edit (.-root this))""", "", 574) +mid273 = (u""" (- level 5)""", "", 575) +mid274 = (u""" tail-node)""", "", 576) +mid275 = (u""" (push-tail this""", "", 577) +mid276 = (u""" (- level 5)""", "", 578) +mid277 = (u""" child""", "", 579) +mid278 = (u""" tail-node))))]""", "", 580) +mid279 = (u""" (aset ret-array subidx node-to-insert)""", "", 581) +mid280 = (u""" (->Node (.-edit parent) ret-array)))""", "", 582) +mid281 = (u""" (let [sub-idx (bit-and (bit-shift-right (dec (.-cnt)) level) 0x01F)]""", "", 585) +mid282 = (u""" (> level 5)""", "", 587) +mid283 = (u""" (let [new-child (pop-tail (- level 5)""", "", 588) +mid284 = (u""" (aget (.-array node) sub-idx))]""", "", 589) +mid285 = (u""" (if (or (nil? new-child)""", "", 590) +mid286 = (u""" (= sub-idx 0))""", "", 591) +mid287 = (u""" (let [root (.-root this)""", "", 593) +mid288 = (u""" ret (->Node (.-edit root)""", "", 594) +mid289 = (u""" (.-array node))]""", "", 595) +mid290 = (u""" (aset (.-array ret) sub-idx new-child)""", "", 596) +mid291 = (u""" ret)))""", "", 597) +mid292 = (u""" (= sub-idx 0)""", "", 599) +mid293 = (u""" (let [root (.-root this)""", "", 603) +mid294 = (u""" ret (->Node (.-edit root)""", "", 604) +mid295 = (u""" (aclone (.-array node)))]""", "", 605) +mid296 = (u""" (aset (.-array ret) nil)""", "", 606) +mid297 = (u""" ret))))""", "", 607) +mid298 = (u""" (cond""", "", 586) +mid299 = (u""" (if (= level 0)""", "", 610) +mid300 = (u""" node""", "", 611) +mid301 = (u""" (let [nnode (new-node edit)]""", "", 612) +mid302 = (u""" (aset (.-array nnode) 0 (new-path edit (- level 5) node))""", "", 613) +mid303 = (u""" nnode)))""", "", 614) +mid304 = (u"""(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil))""", "", 617) +mid305 = (u""" (if (< (count arr) 32)""", "", 620) +mid306 = (u""" (->PersistentVector (count arr) 5 EMPTY-NODE arr nil)""", "", 621) +mid307 = (u""" (into [] arr)))""", "", 622) +mid308 = (u""" (-reduce [this f init]""", "", 636) +mid309 = (u"""(extend-type Array""", "", 626) +mid310 = (u""" acc init]""", "", 638) +mid311 = (u""" (loop [idx 0""", "", 637) +mid312 = (u""" (if (reduced? acc)""", "", 639) +mid313 = (u""" @acc""", "", 640) +mid314 = (u""" (if (< idx (count this))""", "", 641) +mid315 = (u""" (recur (inc idx)""", "", 642) +mid316 = (u""" (f acc (aget this idx)))""", "", 643) +mid317 = (u""" acc)))))""", "", 644) +mid318 = (u""" (-count ([arr]""", "", 632) +mid319 = (u""" (.-count arr)))""", "", 633) +mid320 = (u""" (-conj [arr itm]""", "", 628) +mid321 = (u""" (conj (vector-from-array arr) itm))""", "", 629) +mid322 = (u""" (loop [idx 0]""", "", 647) +mid323 = (u""" (when (< idx size)""", "", 648) +mid324 = (u""" (do (aset to (+ to-idx idx) (aget from (+ from-idx idx)))""", "", 649) +mid325 = (u""" (recur (inc idx))))))""", "", 650) +mid326 = (u""" (let [new-array (make-array (inc (count arr)))]""", "", 653) +mid327 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 654) +mid328 = (u""" (aset new-array (count arr) val)""", "", 655) +mid329 = (u""" new-array))""", "", 656) +mid330 = (u""" (let [new-array (make-array (count arr))]""", "", 659) +mid331 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 660) +mid332 = (u""" new-array))""", "", 661) +mid333 = (u""" v (into [] (range MAX))]""", "", 666) +mid334 = (u""" (dotimes [x MAX]""", "", 667) +mid335 = (u""" (println x)""", "", 668) +mid336 = (u""" (assert (= x (nth v x)))))""", "", 669) +mid337 = (u"""(let [MAX 1024""", "", 665) +mid338 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) code_ast=i.Do( @@ -277,7 +349,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"ISeq")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"ISeq")), ], meta=nil)]), @@ -287,9 +359,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-first")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-first")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid0, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid2, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -298,13 +370,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-next")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-next")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid0, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid2, 14)), ], meta=nil)]), ], - meta=i.Meta(mid0, 1)), + meta=i.Meta(mid2, 1)), i.Do( args=[ i.Invoke(args=[ @@ -313,7 +385,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"ISeqable")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"ISeqable")), ], meta=nil)]), @@ -323,13 +395,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-seq")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-seq")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid1, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid3, 14)), ], meta=nil)]), ], - meta=i.Meta(mid1, 1)), + meta=i.Meta(mid3, 1)), i.Do( args=[ i.Invoke(args=[ @@ -338,7 +410,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"ICounted")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"ICounted")), ], meta=nil)]), @@ -348,13 +420,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-count")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-count")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ICounted"), meta=i.Meta(mid2, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ICounted"), meta=i.Meta(mid4, 14)), ], meta=nil)]), ], - meta=i.Meta(mid2, 1)), + meta=i.Meta(mid4, 1)), i.Do( args=[ i.Invoke(args=[ @@ -363,7 +435,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IIndexed")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IIndexed")), ], meta=nil)]), @@ -373,9 +445,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-nth")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-nth")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid3, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid5, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -384,13 +456,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-nth-not-found")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-nth-not-found")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid3, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid5, 14)), ], meta=nil)]), ], - meta=i.Meta(mid3, 1)), + meta=i.Meta(mid5, 1)), i.Do( args=[ i.Invoke(args=[ @@ -399,7 +471,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IPersistentCollection")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IPersistentCollection")), ], meta=nil)]), @@ -409,9 +481,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-conj")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-conj")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid4, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid6, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -420,13 +492,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-disj")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-disj")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid4, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid6, 14)), ], meta=nil)]), ], - meta=i.Meta(mid4, 1)), + meta=i.Meta(mid6, 1)), i.Do( args=[ i.Invoke(args=[ @@ -435,7 +507,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IEmpty")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IEmpty")), ], meta=nil)]), @@ -445,13 +517,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-empty")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-empty")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IEmpty"), meta=i.Meta(mid5, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IEmpty"), meta=i.Meta(mid7, 14)), ], meta=nil)]), ], - meta=i.Meta(mid5, 1)), + meta=i.Meta(mid7, 1)), i.Do( args=[ i.Invoke(args=[ @@ -460,7 +532,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IObject")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IObject")), ], meta=nil)]), @@ -470,9 +542,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-hash")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-hash")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -481,9 +553,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-eq")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-eq")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -492,9 +564,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-str")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-str")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -503,13 +575,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-repr")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-repr")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid6, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), ], meta=nil)]), ], - meta=i.Meta(mid6, 1)), + meta=i.Meta(mid8, 1)), i.Do( args=[ i.Invoke(args=[ @@ -518,7 +590,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IReduce")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IReduce")), ], meta=nil)]), @@ -528,13 +600,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-reduce")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-reduce")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IReduce"), meta=i.Meta(mid7, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IReduce"), meta=i.Meta(mid9, 14)), ], meta=nil)]), ], - meta=i.Meta(mid7, 1)), + meta=i.Meta(mid9, 1)), i.Do( args=[ i.Invoke(args=[ @@ -543,7 +615,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IDeref")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IDeref")), ], meta=nil)]), @@ -553,13 +625,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-deref")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-deref")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IDeref"), meta=i.Meta(mid8, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IDeref"), meta=i.Meta(mid10, 14)), ], meta=nil)]), ], - meta=i.Meta(mid8, 1)), + meta=i.Meta(mid10, 1)), i.Do( args=[ i.Invoke(args=[ @@ -568,7 +640,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IReset")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IReset")), ], meta=nil)]), @@ -578,13 +650,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-reset!")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-reset!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IReset"), meta=i.Meta(mid9, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IReset"), meta=i.Meta(mid11, 14)), ], meta=nil)]), ], - meta=i.Meta(mid9, 1)), + meta=i.Meta(mid11, 1)), i.Do( args=[ i.Invoke(args=[ @@ -593,7 +665,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"INamed")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"INamed")), ], meta=nil)]), @@ -603,9 +675,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-namespace")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-namespace")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid10, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid12, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -614,13 +686,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-name")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-name")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid10, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid12, 14)), ], meta=nil)]), ], - meta=i.Meta(mid10, 1)), + meta=i.Meta(mid12, 1)), i.Do( args=[ i.Invoke(args=[ @@ -629,7 +701,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IAssociative")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IAssociative")), ], meta=nil)]), @@ -639,9 +711,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-assoc")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-assoc")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid11, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid13, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -650,9 +722,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-contains-key")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-contains-key")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid11, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid13, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -661,13 +733,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-dissoc")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-dissoc")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid11, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid13, 14)), ], meta=nil)]), ], - meta=i.Meta(mid11, 1)), + meta=i.Meta(mid13, 1)), i.Do( args=[ i.Invoke(args=[ @@ -676,7 +748,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"ILookup")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"ILookup")), ], meta=nil)]), @@ -686,13 +758,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-get")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-get")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ILookup"), meta=i.Meta(mid12, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ILookup"), meta=i.Meta(mid14, 14)), ], meta=nil)]), ], - meta=i.Meta(mid12, 1)), + meta=i.Meta(mid14, 1)), i.Do( args=[ i.Invoke(args=[ @@ -701,7 +773,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IMapEntry")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IMapEntry")), ], meta=nil)]), @@ -711,9 +783,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-key")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-key")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid13, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid15, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -722,13 +794,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-val")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-val")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid13, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid15, 14)), ], meta=nil)]), ], - meta=i.Meta(mid13, 1)), + meta=i.Meta(mid15, 1)), i.Do( args=[ i.Invoke(args=[ @@ -737,7 +809,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IStack")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IStack")), ], meta=nil)]), @@ -747,13 +819,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-push")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-push")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IStack"), meta=i.Meta(mid14, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IStack"), meta=i.Meta(mid16, 14)), ], meta=nil)]), ], - meta=i.Meta(mid14, 1)), + meta=i.Meta(mid16, 1)), i.Do( args=[ i.Invoke(args=[ @@ -762,7 +834,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IPop")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IPop")), ], meta=nil)]), @@ -772,13 +844,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-pop")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-pop")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IPop"), meta=i.Meta(mid15, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IPop"), meta=i.Meta(mid17, 14)), ], meta=nil)]), ], - meta=i.Meta(mid15, 1)), + meta=i.Meta(mid17, 1)), i.Do( args=[ i.Invoke(args=[ @@ -787,7 +859,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IFn")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IFn")), ], meta=nil)]), @@ -797,13 +869,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-invoke")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-invoke")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IFn"), meta=i.Meta(mid16, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IFn"), meta=i.Meta(mid18, 14)), ], meta=nil)]), ], - meta=i.Meta(mid16, 1)), + meta=i.Meta(mid18, 1)), i.Do( args=[ i.Invoke(args=[ @@ -812,7 +884,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IDoc")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IDoc")), ], meta=nil)]), @@ -822,20 +894,20 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-doc")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-doc")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IDoc"), meta=i.Meta(mid17, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IDoc"), meta=i.Meta(mid19, 14)), ], meta=nil)]), ], - meta=i.Meta(mid17, 1)), + meta=i.Meta(mid19, 1)), i.Invoke(args=[ # (def pixie.stdlib/IVector) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), i.Const(code.intern_var(u"pixie.stdlib",u"IVector")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IVector")), ], meta=nil)]), @@ -845,7 +917,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"ISequential")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"ISequential")), ], meta=nil)]), @@ -855,7 +927,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IMap")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IMap")), ], meta=nil)]), @@ -867,7 +939,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IMeta")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IMeta")), ], meta=nil)]), @@ -877,9 +949,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-with-meta")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-with-meta")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid18, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid20, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -888,13 +960,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-meta")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-meta")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid18, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid20, 14)), ], meta=nil)]), ], - meta=i.Meta(mid18, 1)), + meta=i.Meta(mid20, 1)), i.Do( args=[ i.Invoke(args=[ @@ -903,7 +975,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"ITransientCollection")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"ITransientCollection")), ], meta=nil)]), @@ -913,13 +985,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-conj!")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-conj!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientCollection"), meta=i.Meta(mid19, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientCollection"), meta=i.Meta(mid21, 14)), ], meta=nil)]), ], - meta=i.Meta(mid19, 1)), + meta=i.Meta(mid21, 1)), i.Do( args=[ i.Invoke(args=[ @@ -928,7 +1000,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IToTransient")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IToTransient")), ], meta=nil)]), @@ -938,13 +1010,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-transient")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-transient")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid20, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid22, 14)), ], meta=nil)]), ], - meta=i.Meta(mid20, 1)), + meta=i.Meta(mid22, 1)), i.Do( args=[ i.Invoke(args=[ @@ -953,7 +1025,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"ITransientStack")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"ITransientStack")), ], meta=nil)]), @@ -963,9 +1035,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-push!")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-push!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid21, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid23, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -974,13 +1046,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-pop!")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-pop!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid21, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid23, 14)), ], meta=nil)]), ], - meta=i.Meta(mid21, 1)), + meta=i.Meta(mid23, 1)), i.Do( args=[ i.Invoke(args=[ @@ -989,7 +1061,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IDisposable")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IDisposable")), ], meta=nil)]), @@ -999,13 +1071,13 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-dispose!")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-dispose!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IDisposable"), meta=i.Meta(mid22, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IDisposable"), meta=i.Meta(mid24, 14)), ], meta=nil)]), ], - meta=i.Meta(mid22, 1)), + meta=i.Meta(mid24, 1)), i.Do( args=[ i.Invoke(args=[ @@ -1014,7 +1086,7 @@ i.Const(code.intern_var(u"pixie.stdlib",u"IMessageObject")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), i.Const(rt.wrap(u"IMessageObject")), ], meta=nil)]), @@ -1024,9 +1096,9 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-get-field")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-get-field")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid23, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid25, 14)), ], meta=nil)]), i.Invoke(args=[ @@ -1035,84 +1107,98 @@ i.Const(code.intern_var(u"pixie.stdlib",u"-invoke-method")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), i.Const(rt.wrap(u"-invoke-method")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid23, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid25, 14)), ], meta=nil)]), ], - meta=i.Meta(mid23, 1)), + meta=i.Meta(mid25, 1)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid24, 2)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid24, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid24, 20)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-get-field"), meta=i.Meta(mid24, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid26, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid26, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid26, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-get-field"), meta=i.Meta(mid26, 27)), ], - meta=i.Meta(mid24, 1)), - i.Invoke( + meta=i.Meta(mid26, 1)), + i.Do( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid25, 2)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid25, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid25, 14)), - i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_353"), - body=i.TailCall( - args=[ - i.Lookup(kw(u"sb"), meta=i.Meta(mid26, 24)), - i.Invoke( + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid27, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid28, 14)), + i.Fn(args=[kw(u"this"),kw(u"other")],name=kw(u"fn_360"), + body=i.Const(false), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid29, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid28, 14)), + i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_363"), + body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-str"), meta=i.Meta(mid26, 28)), - i.Lookup(kw(u"x"), meta=i.Meta(mid26, 45)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid30, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-repr"), meta=i.Meta(mid30, 10)), + i.Lookup(kw(u"x"), meta=i.Meta(mid30, 28)), + ], + meta=i.Meta(mid30, 9)), ], - meta=i.Meta(mid26, 27)), - ], - meta=i.Meta(mid26, 23)), - ), - ], - meta=i.Meta(mid25, 1)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid27, 2)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid27, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid27, 15)), - i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_356"), - body=i.TailCall( - args=[ - i.Lookup(kw(u"sb"), meta=i.Meta(mid28, 25)), - i.Invoke( + meta=i.Meta(mid30, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid31, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid28, 14)), + i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_357"), + body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-repr"), meta=i.Meta(mid28, 29)), - i.Lookup(kw(u"x"), meta=i.Meta(mid28, 47)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid32, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-str"), meta=i.Meta(mid32, 10)), + i.Lookup(kw(u"x"), meta=i.Meta(mid32, 27)), + ], + meta=i.Meta(mid32, 9)), ], - meta=i.Meta(mid28, 28)), - ], - meta=i.Meta(mid28, 24)), - ), + meta=i.Meta(mid32, 5)), + ), + ], + meta=nil), ], - meta=i.Meta(mid27, 1)), + meta=i.Meta(mid28, 1)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid29, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid30, 14)), - i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"fn_359"), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid33, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid34, 14)), + i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"fn_366"), body=i.TailCall( args=[ - i.Lookup(kw(u"sb"), meta=i.Meta(mid31, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid31, 9)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid35, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid35, 9)), ], - meta=i.Meta(mid31, 5)), + meta=i.Meta(mid35, 5)), ), ], meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid32, 2)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid32, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Number"), meta=i.Meta(mid32, 13)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-num-eq"), meta=i.Meta(mid32, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid36, 2)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid36, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Number"), meta=i.Meta(mid36, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-num-eq"), meta=i.Meta(mid36, 20)), ], - meta=i.Meta(mid32, 1)), + meta=i.Meta(mid36, 1)), i.Invoke(args=[ # (def pixie.stdlib/+) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -1122,34 +1208,34 @@ body=i.Const(rt.wrap(0)), ), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"+"), - body=i.Lookup(kw(u"x"), meta=i.Meta(mid33, 8)), + body=i.Lookup(kw(u"x"), meta=i.Meta(mid37, 8)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"+"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add"), meta=i.Meta(mid34, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid34, 16)), - i.Lookup(kw(u"y"), meta=i.Meta(mid34, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add"), meta=i.Meta(mid38, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid38, 16)), + i.Lookup(kw(u"y"), meta=i.Meta(mid38, 18)), ], - meta=i.Meta(mid34, 10)), + meta=i.Meta(mid38, 10)), ), i.Const(rt.wrap(-1)), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"+"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid35, 5)), - i.Lookup(kw(u"+"), meta=i.Meta(mid35, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid39, 5)), + i.Lookup(kw(u"+"), meta=i.Meta(mid39, 12)), i.Invoke( args=[ - i.Lookup(kw(u"+"), meta=i.Meta(mid35, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid35, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid35, 19)), + i.Lookup(kw(u"+"), meta=i.Meta(mid39, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid39, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid39, 19)), ], - meta=i.Meta(mid35, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid35, 22)), + meta=i.Meta(mid39, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid39, 22)), ], - meta=i.Meta(mid35, 4)), + meta=i.Meta(mid39, 4)), )]) ])]), i.Invoke(args=[ @@ -1161,34 +1247,34 @@ body=i.Const(rt.wrap(0)), ), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"-"), - body=i.Lookup(kw(u"x"), meta=i.Meta(mid36, 8)), + body=i.Lookup(kw(u"x"), meta=i.Meta(mid40, 8)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"-"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-sub"), meta=i.Meta(mid37, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid37, 16)), - i.Lookup(kw(u"y"), meta=i.Meta(mid37, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-sub"), meta=i.Meta(mid41, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid41, 16)), + i.Lookup(kw(u"y"), meta=i.Meta(mid41, 18)), ], - meta=i.Meta(mid37, 10)), + meta=i.Meta(mid41, 10)), ), i.Const(rt.wrap(-1)), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"-"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid38, 5)), - i.Lookup(kw(u"-"), meta=i.Meta(mid38, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid42, 5)), + i.Lookup(kw(u"-"), meta=i.Meta(mid42, 12)), i.Invoke( args=[ - i.Lookup(kw(u"-"), meta=i.Meta(mid38, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid38, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid38, 19)), + i.Lookup(kw(u"-"), meta=i.Meta(mid42, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid42, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid42, 19)), ], - meta=i.Meta(mid38, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid38, 22)), + meta=i.Meta(mid42, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid42, 22)), ], - meta=i.Meta(mid38, 4)), + meta=i.Meta(mid42, 4)), )]) ])]), i.Invoke(args=[ @@ -1198,11 +1284,11 @@ i.Fn(args=[kw(u"x")],name=kw(u"inc"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid39, 9)), - i.Lookup(kw(u"x"), meta=i.Meta(mid39, 11)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid43, 9)), + i.Lookup(kw(u"x"), meta=i.Meta(mid43, 11)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid39, 8)), + meta=i.Meta(mid43, 8)), )]), i.Invoke(args=[ # (def pixie.stdlib/dec) @@ -1211,11 +1297,11 @@ i.Fn(args=[kw(u"x")],name=kw(u"dec"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid40, 9)), - i.Lookup(kw(u"x"), meta=i.Meta(mid40, 11)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid44, 9)), + i.Lookup(kw(u"x"), meta=i.Meta(mid44, 11)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid40, 8)), + meta=i.Meta(mid44, 8)), )]), i.Invoke(args=[ # (def pixie.stdlib/<) @@ -1225,29 +1311,29 @@ i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"<"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-lt"), meta=i.Meta(mid41, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid41, 15)), - i.Lookup(kw(u"y"), meta=i.Meta(mid41, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-lt"), meta=i.Meta(mid45, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid45, 15)), + i.Lookup(kw(u"y"), meta=i.Meta(mid45, 17)), ], - meta=i.Meta(mid41, 10)), + meta=i.Meta(mid45, 10)), ), i.Const(rt.wrap(-1)), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"<"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid42, 5)), - i.Lookup(kw(u"<"), meta=i.Meta(mid42, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid46, 5)), + i.Lookup(kw(u"<"), meta=i.Meta(mid46, 12)), i.Invoke( args=[ - i.Lookup(kw(u"<"), meta=i.Meta(mid42, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid42, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid42, 19)), + i.Lookup(kw(u"<"), meta=i.Meta(mid46, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid46, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid46, 19)), ], - meta=i.Meta(mid42, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid42, 22)), + meta=i.Meta(mid46, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid46, 22)), ], - meta=i.Meta(mid42, 4)), + meta=i.Meta(mid46, 4)), )]) ])]), i.Invoke(args=[ @@ -1258,29 +1344,109 @@ i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u">"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-gt"), meta=i.Meta(mid43, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid43, 15)), - i.Lookup(kw(u"y"), meta=i.Meta(mid43, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-gt"), meta=i.Meta(mid47, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid47, 15)), + i.Lookup(kw(u"y"), meta=i.Meta(mid47, 17)), ], - meta=i.Meta(mid43, 10)), + meta=i.Meta(mid47, 10)), ), i.Const(rt.wrap(-1)), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u">"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid44, 5)), - i.Lookup(kw(u">"), meta=i.Meta(mid44, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid48, 5)), + i.Lookup(kw(u">"), meta=i.Meta(mid48, 12)), i.Invoke( args=[ - i.Lookup(kw(u">"), meta=i.Meta(mid44, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid44, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid44, 19)), + i.Lookup(kw(u">"), meta=i.Meta(mid48, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid48, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid48, 19)), ], - meta=i.Meta(mid44, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid44, 22)), + meta=i.Meta(mid48, 14)), + i.Lookup(kw(u"more"), meta=i.Meta(mid48, 22)), + ], + meta=i.Meta(mid48, 4)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/<=) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"<=")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"<=")), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"<="), + body=i.Const(true), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"<="), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-lte"), meta=i.Meta(mid49, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid49, 16)), + i.Lookup(kw(u"y"), meta=i.Meta(mid49, 18)), + ], + meta=i.Meta(mid49, 10)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"rest")],name=kw(u"<="), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-lte"), meta=i.Meta(mid50, 22)), + i.Lookup(kw(u"x"), meta=i.Meta(mid50, 27)), + i.Lookup(kw(u"y"), meta=i.Meta(mid50, 29)), + ], + meta=i.Meta(mid50, 21)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid51, 20)), + i.Lookup(kw(u"<="), meta=i.Meta(mid51, 26)), + i.Lookup(kw(u"y"), meta=i.Meta(mid51, 29)), + i.Lookup(kw(u"rest"), meta=i.Meta(mid51, 31)), + ], + meta=i.Meta(mid51, 19)), + els=i.Const(nil), + meta=i.Meta(mid50, 17)), + )]) + ])]), + i.Invoke(args=[ +# (def pixie.stdlib/>=) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u">=")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u">=")), + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u">="), + body=i.Const(true), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u">="), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-gte"), meta=i.Meta(mid52, 11)), + i.Lookup(kw(u"x"), meta=i.Meta(mid52, 16)), + i.Lookup(kw(u"y"), meta=i.Meta(mid52, 18)), ], - meta=i.Meta(mid44, 4)), + meta=i.Meta(mid52, 10)), + ), + i.Const(rt.wrap(-1)), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), + i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"rest")],name=kw(u">="), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-gte"), meta=i.Meta(mid53, 22)), + i.Lookup(kw(u"x"), meta=i.Meta(mid53, 27)), + i.Lookup(kw(u"y"), meta=i.Meta(mid53, 29)), + ], + meta=i.Meta(mid53, 21)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid54, 20)), + i.Lookup(kw(u">="), meta=i.Meta(mid54, 26)), + i.Lookup(kw(u"y"), meta=i.Meta(mid54, 29)), + i.Lookup(kw(u"rest"), meta=i.Meta(mid54, 31)), + ], + meta=i.Meta(mid54, 19)), + els=i.Const(nil), + meta=i.Meta(mid53, 17)), )]) ])]), i.Invoke(args=[ @@ -1295,20 +1461,20 @@ body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"identical?"), meta=i.Meta(mid45, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid45, 26)), - i.Lookup(kw(u"y"), meta=i.Meta(mid45, 28)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"identical?"), meta=i.Meta(mid55, 15)), + i.Lookup(kw(u"x"), meta=i.Meta(mid55, 26)), + i.Lookup(kw(u"y"), meta=i.Meta(mid55, 28)), ], - meta=i.Meta(mid45, 14)), + meta=i.Meta(mid55, 14)), then=i.Const(true), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid46, 13)), - i.Lookup(kw(u"x"), meta=i.Meta(mid46, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid46, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid56, 13)), + i.Lookup(kw(u"x"), meta=i.Meta(mid56, 17)), + i.Lookup(kw(u"y"), meta=i.Meta(mid56, 19)), ], - meta=i.Meta(mid46, 12)), - meta=i.Meta(mid45, 10)), + meta=i.Meta(mid56, 12)), + meta=i.Meta(mid55, 10)), ), i.Const(rt.wrap(-1)), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), @@ -1316,21 +1482,21 @@ body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"eq"), meta=i.Meta(mid47, 22)), - i.Lookup(kw(u"x"), meta=i.Meta(mid47, 25)), - i.Lookup(kw(u"y"), meta=i.Meta(mid47, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"eq"), meta=i.Meta(mid57, 22)), + i.Lookup(kw(u"x"), meta=i.Meta(mid57, 25)), + i.Lookup(kw(u"y"), meta=i.Meta(mid57, 27)), ], - meta=i.Meta(mid47, 21)), + meta=i.Meta(mid57, 21)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid48, 20)), - i.Lookup(kw(u"="), meta=i.Meta(mid48, 26)), - i.Lookup(kw(u"y"), meta=i.Meta(mid48, 28)), - i.Lookup(kw(u"rest"), meta=i.Meta(mid48, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid58, 20)), + i.Lookup(kw(u"="), meta=i.Meta(mid58, 26)), + i.Lookup(kw(u"y"), meta=i.Meta(mid58, 28)), + i.Lookup(kw(u"rest"), meta=i.Meta(mid58, 30)), ], - meta=i.Meta(mid48, 19)), + meta=i.Meta(mid58, 19)), els=i.Const(nil), - meta=i.Meta(mid47, 17)), + meta=i.Meta(mid57, 17)), )]) ])]), i.Invoke(args=[ @@ -1343,47 +1509,72 @@ i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), ), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"coll")],name=kw(u"conj"), - body=i.Lookup(kw(u"coll"), meta=i.Meta(mid49, 11)), + body=i.Lookup(kw(u"coll"), meta=i.Meta(mid59, 11)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"coll"),kw(u"itm")],name=kw(u"conj"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid50, 16)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid50, 22)), - i.Lookup(kw(u"itm"), meta=i.Meta(mid50, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid60, 16)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid60, 22)), + i.Lookup(kw(u"itm"), meta=i.Meta(mid60, 27)), ], - meta=i.Meta(mid50, 15)), + meta=i.Meta(mid60, 15)), ), i.Const(rt.wrap(-1)), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"coll"),kw(u"item"),kw(u"more")],name=kw(u"conj"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid51, 5)), - i.Lookup(kw(u"conj"), meta=i.Meta(mid51, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid61, 5)), + i.Lookup(kw(u"conj"), meta=i.Meta(mid61, 12)), i.Invoke( args=[ - i.Lookup(kw(u"conj"), meta=i.Meta(mid51, 18)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"x"), meta=i.Meta(mid51, 23)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"y"), meta=i.Meta(mid51, 25)), + i.Lookup(kw(u"conj"), meta=i.Meta(mid61, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"x"), meta=i.Meta(mid61, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"y"), meta=i.Meta(mid61, 25)), ], - meta=i.Meta(mid51, 17)), - i.Lookup(kw(u"more"), meta=i.Meta(mid51, 28)), + meta=i.Meta(mid61, 17)), + i.Lookup(kw(u"more"), meta=i.Meta(mid61, 28)), ], - meta=i.Meta(mid51, 4)), + meta=i.Meta(mid61, 4)), )]) ])]), i.Invoke(args=[ +# (def pixie.stdlib/nth) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"nth")), + i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"nth")), + i.Const(rt.wrap(3)), i.Fn(args=[kw(u"coll"),kw(u"idx"),kw(u"not-found")],name=kw(u"nth"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid62, 26)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid62, 41)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid62, 46)), + i.Lookup(kw(u"not-found"), meta=i.Meta(mid62, 50)), + ], + meta=i.Meta(mid62, 25)), + ), + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"coll"),kw(u"idx")],name=kw(u"nth"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid63, 16)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid63, 21)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid63, 26)), + ], + meta=i.Meta(mid63, 15)), + ), + ])]), + i.Invoke(args=[ # (def pixie.stdlib/count) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), i.Const(code.intern_var(u"pixie.stdlib",u"count")), i.Fn(args=[kw(u"coll")],name=kw(u"count"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid52, 12)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid52, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid64, 12)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid64, 19)), ], - meta=i.Meta(mid52, 11)), + meta=i.Meta(mid64, 11)), )]), i.Do( args=[ @@ -1394,7 +1585,7 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"Cons")), + i.Const(kw(u"pixie.stdlib.Cons")), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"first")), i.Const(kw(u"next")), @@ -1410,7 +1601,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid65, 10)), i.Lookup(kw(u"first"), meta=nil), i.Lookup(kw(u"next"), meta=nil), i.Lookup(kw(u"meta"), meta=nil), @@ -1420,13 +1611,13 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-first"), meta=i.Meta(mid54, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-first"), meta=i.Meta(mid66, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), i.Fn(args=[kw(u"this")],name=kw(u"-first_Cons"), body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid54, 12)), + i.Lookup(kw(u"this"), meta=i.Meta(mid66, 12)), i.Const(kw(u"first")), ], meta=nil), @@ -1436,13 +1627,13 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-next"), meta=i.Meta(mid55, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-next"), meta=i.Meta(mid67, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), i.Fn(args=[kw(u"this")],name=kw(u"-next_Cons"), body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid55, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid67, 11)), i.Const(kw(u"next")), ], meta=nil), @@ -1452,23 +1643,23 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid56, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid68, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), i.Fn(args=[kw(u"this")],name=kw(u"-seq_Cons"), - body=i.Lookup(kw(u"this"), meta=i.Meta(mid56, 16)), + body=i.Lookup(kw(u"this"), meta=i.Meta(mid68, 16)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-meta"), meta=i.Meta(mid57, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-meta"), meta=i.Meta(mid69, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), i.Fn(args=[kw(u"this")],name=kw(u"-meta_Cons"), body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid57, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid69, 11)), i.Const(kw(u"meta")), ], meta=nil), @@ -1478,34 +1669,34 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-with-meta"), meta=i.Meta(mid58, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid53, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-with-meta"), meta=i.Meta(mid70, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), i.Fn(args=[kw(u"this"),kw(u"new-meta")],name=kw(u"-with-meta_Cons"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid59, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid71, 6)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid58, 16)), + i.Lookup(kw(u"this"), meta=i.Meta(mid70, 16)), i.Const(kw(u"first")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid58, 16)), + i.Lookup(kw(u"this"), meta=i.Meta(mid70, 16)), i.Const(kw(u"next")), ], meta=nil), - i.Lookup(kw(u"new-meta"), meta=i.Meta(mid59, 24)), + i.Lookup(kw(u"new-meta"), meta=i.Meta(mid71, 24)), ], - meta=i.Meta(mid59, 5)), + meta=i.Meta(mid71, 5)), ), ], meta=nil), ], - meta=i.Meta(mid53, 1)), + meta=i.Meta(mid65, 1)), i.Invoke(args=[ # (def pixie.stdlib/cons) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -1513,17 +1704,17 @@ i.Fn(args=[kw(u"head"),kw(u"tail")],name=kw(u"cons"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid60, 4)), - i.Lookup(kw(u"head"), meta=i.Meta(mid60, 11)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid72, 4)), + i.Lookup(kw(u"head"), meta=i.Meta(mid72, 11)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid60, 17)), - i.Lookup(kw(u"tail"), meta=i.Meta(mid60, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid72, 17)), + i.Lookup(kw(u"tail"), meta=i.Meta(mid72, 21)), ], - meta=i.Meta(mid60, 16)), + meta=i.Meta(mid72, 16)), i.Const(nil), ], - meta=i.Meta(mid60, 3)), + meta=i.Meta(mid72, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/string-builder) @@ -1533,45 +1724,45 @@ i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"string-builder"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid61, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid73, 8)), ], - meta=i.Meta(mid61, 7)), + meta=i.Meta(mid73, 7)), ), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"sb")],name=kw(u"string-builder"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid62, 10)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid62, 15)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid74, 10)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid74, 15)), ], - meta=i.Meta(mid62, 9)), + meta=i.Meta(mid74, 9)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"sb"),kw(u"x")],name=kw(u"string-builder"), body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid63, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid63, 19)), - i.Lookup(kw(u"x"), meta=i.Meta(mid63, 26)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid75, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid75, 19)), + i.Lookup(kw(u"x"), meta=i.Meta(mid75, 26)), ], - meta=i.Meta(mid63, 8)), + meta=i.Meta(mid75, 8)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid64, 7)), - i.Lookup(kw(u"x"), meta=i.Meta(mid64, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid76, 7)), + i.Lookup(kw(u"x"), meta=i.Meta(mid76, 30)), ], - meta=i.Meta(mid64, 6)), + meta=i.Meta(mid76, 6)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-bulder"), meta=i.Meta(mid65, 7)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-bulder"), meta=i.Meta(mid77, 7)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid65, 30)), - i.Lookup(kw(u"x"), meta=i.Meta(mid65, 35)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid77, 30)), + i.Lookup(kw(u"x"), meta=i.Meta(mid77, 35)), ], - meta=i.Meta(mid65, 29)), + meta=i.Meta(mid77, 29)), ], - meta=i.Meta(mid65, 6)), - meta=i.Meta(mid63, 4)), + meta=i.Meta(mid77, 6)), + meta=i.Meta(mid75, 4)), ), ])]), i.Invoke(args=[ @@ -1582,17 +1773,17 @@ i.Fn(args=[kw(u"args")],name=kw(u"str"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid66, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid78, 4)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"map"), meta=i.Meta(mid67, 5)), - i.Lookup(kw(u"str"), meta=i.Meta(mid67, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"map"), meta=i.Meta(mid79, 5)), + i.Lookup(kw(u"str"), meta=i.Meta(mid79, 9)), ], - meta=i.Meta(mid67, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"string-builder"), meta=i.Meta(mid68, 4)), - i.Lookup(kw(u"args"), meta=i.Meta(mid69, 4)), + meta=i.Meta(mid79, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"string-builder"), meta=i.Meta(mid80, 4)), + i.Lookup(kw(u"args"), meta=i.Meta(mid81, 4)), ], - meta=i.Meta(mid66, 3)), + meta=i.Meta(mid78, 3)), )])]), i.Invoke(args=[ # (def pixie.stdlib/println) @@ -1604,17 +1795,17 @@ bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid70, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid82, 13)), ], - meta=i.Meta(mid70, 12)), - i.Fn(args=[kw(u"x")],name=kw(u"fn_415"),closed_overs=[kw(u"sb")], + meta=i.Meta(mid82, 12)), + i.Fn(args=[kw(u"x")],name=kw(u"fn_439"),closed_overs=[kw(u"sb")], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid71, 19)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid71, 42)), - i.Lookup(kw(u"x"), meta=i.Meta(mid71, 45)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid83, 19)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid83, 42)), + i.Lookup(kw(u"x"), meta=i.Meta(mid83, 45)), ], - meta=i.Meta(mid71, 18)), + meta=i.Meta(mid83, 18)), ), ], body=i.Do( @@ -1622,87 +1813,87 @@ i.Let(names=[kw(u"idx"),kw(u"sb")], bindings=[ i.Const(rt.wrap(0)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid72, 15)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid84, 15)), ], body=i.Invoke( args=[ i.Fn(args=[kw(u"idx"),kw(u"sb")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"args"),kw(u"add-fn")], body=i.Let(names=[kw(u"idx"),kw(u"sb")], bindings=[ - i.Lookup(kw(u"idx"), meta=i.Meta(mid73, 12)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid72, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid85, 12)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid84, 12)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid74, 12)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid74, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid86, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid86, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid74, 19)), - i.Lookup(kw(u"args"), meta=i.Meta(mid74, 25)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid86, 19)), + i.Lookup(kw(u"args"), meta=i.Meta(mid86, 25)), ], - meta=i.Meta(mid74, 18)), + meta=i.Meta(mid86, 18)), ], - meta=i.Meta(mid74, 11)), + meta=i.Meta(mid86, 11)), then=i.TailCall( args=[ i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid75, 17)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid75, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid87, 17)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid87, 21)), ], - meta=i.Meta(mid75, 16)), + meta=i.Meta(mid87, 16)), i.Do( args=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid76, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid88, 21)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid76, 27)), - i.Lookup(kw(u"args"), meta=i.Meta(mid76, 32)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid76, 37)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid88, 27)), + i.Lookup(kw(u"args"), meta=i.Meta(mid88, 32)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid88, 37)), ], - meta=i.Meta(mid76, 26)), - i.Lookup(kw(u"add-fn"), meta=i.Meta(mid76, 42)), + meta=i.Meta(mid88, 26)), + i.Lookup(kw(u"add-fn"), meta=i.Meta(mid88, 42)), ], - meta=i.Meta(mid76, 20)), + meta=i.Meta(mid88, 20)), i.Invoke( args=[ - i.Lookup(kw(u"add-fn"), meta=i.Meta(mid77, 21)), + i.Lookup(kw(u"add-fn"), meta=i.Meta(mid89, 21)), i.Const(rt.wrap(u" ")), ], - meta=i.Meta(mid77, 20)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid78, 18)), + meta=i.Meta(mid89, 20)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid90, 18)), ], - meta=i.Meta(mid76, 16)), + meta=i.Meta(mid88, 16)), ], meta=nil), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-blocking-println"), meta=i.Meta(mid79, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-blocking-println"), meta=i.Meta(mid91, 10)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-finish-string-builder"), meta=i.Meta(mid79, 29)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid79, 52)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-finish-string-builder"), meta=i.Meta(mid91, 29)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid91, 52)), ], - meta=i.Meta(mid79, 28)), + meta=i.Meta(mid91, 28)), ], - meta=i.Meta(mid79, 9)), - meta=i.Meta(mid74, 7)), + meta=i.Meta(mid91, 9)), + meta=i.Meta(mid86, 7)), meta=nil), ), - i.Lookup(kw(u"idx"), meta=i.Meta(mid73, 12)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid72, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid85, 12)), + i.Lookup(kw(u"sb"), meta=i.Meta(mid84, 12)), ], meta=nil), - meta=i.Meta(mid73, 5)), + meta=i.Meta(mid85, 5)), i.Const(nil), ], meta=nil), - meta=i.Meta(mid70, 3)), + meta=i.Meta(mid82, 3)), )])]), i.Invoke(args=[ # (def pixie.stdlib/instance?) @@ -1712,65 +1903,65 @@ body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid80, 8)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid80, 20)), - i.Lookup(kw(u"t"), meta=i.Meta(mid80, 29)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid92, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid92, 20)), + i.Lookup(kw(u"t"), meta=i.Meta(mid92, 29)), ], - meta=i.Meta(mid80, 7)), + meta=i.Meta(mid92, 7)), then=i.Let(names=[kw(u"ts")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid81, 15)), - i.Lookup(kw(u"t"), meta=i.Meta(mid81, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid93, 15)), + i.Lookup(kw(u"t"), meta=i.Meta(mid93, 19)), ], - meta=i.Meta(mid81, 14)), + meta=i.Meta(mid93, 14)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid82, 12)), - i.Lookup(kw(u"ts"), meta=i.Meta(mid82, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid94, 12)), + i.Lookup(kw(u"ts"), meta=i.Meta(mid94, 16)), ], - meta=i.Meta(mid82, 11)), + meta=i.Meta(mid94, 11)), then=i.Const(nil), els=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid83, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid95, 16)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid83, 28)), - i.Lookup(kw(u"ts"), meta=i.Meta(mid83, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid95, 28)), + i.Lookup(kw(u"ts"), meta=i.Meta(mid95, 34)), ], - meta=i.Meta(mid83, 27)), - i.Lookup(kw(u"x"), meta=i.Meta(mid83, 38)), + meta=i.Meta(mid95, 27)), + i.Lookup(kw(u"x"), meta=i.Meta(mid95, 38)), ], - meta=i.Meta(mid83, 15)), + meta=i.Meta(mid95, 15)), then=i.Const(true), els=i.TailCall( args=[ - i.Lookup(kw(u"instance?"), meta=i.Meta(mid84, 14)), + i.Lookup(kw(u"instance?"), meta=i.Meta(mid96, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid84, 25)), - i.Lookup(kw(u"ts"), meta=i.Meta(mid84, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid96, 25)), + i.Lookup(kw(u"ts"), meta=i.Meta(mid96, 30)), ], - meta=i.Meta(mid84, 24)), - i.Lookup(kw(u"x"), meta=i.Meta(mid84, 34)), + meta=i.Meta(mid96, 24)), + i.Lookup(kw(u"x"), meta=i.Meta(mid96, 34)), ], - meta=i.Meta(mid84, 13)), - meta=i.Meta(mid83, 11)), - meta=i.Meta(mid82, 7)), - meta=i.Meta(mid81, 5)), + meta=i.Meta(mid96, 13)), + meta=i.Meta(mid95, 11)), + meta=i.Meta(mid94, 7)), + meta=i.Meta(mid93, 5)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid85, 6)), - i.Lookup(kw(u"t"), meta=i.Meta(mid85, 17)), - i.Lookup(kw(u"x"), meta=i.Meta(mid85, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid97, 6)), + i.Lookup(kw(u"t"), meta=i.Meta(mid97, 17)), + i.Lookup(kw(u"x"), meta=i.Meta(mid97, 19)), ], - meta=i.Meta(mid85, 5)), - meta=i.Meta(mid80, 3)), + meta=i.Meta(mid97, 5)), + meta=i.Meta(mid92, 3)), )]), i.Do( args=[ @@ -1781,7 +1972,7 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"Reduced")), + i.Const(kw(u"pixie.stdlib.Reduced")), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"x")), ]), @@ -1795,7 +1986,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid86, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid98, 10)), i.Lookup(kw(u"x"), meta=nil), ], meta=nil), @@ -1803,13 +1994,13 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=i.Meta(mid87, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid86, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=i.Meta(mid99, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=nil), i.Fn(args=[kw(u"this")],name=kw(u"-deref_Reduced"), body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid87, 12)), + i.Lookup(kw(u"this"), meta=i.Meta(mid99, 12)), i.Const(kw(u"x")), ], meta=nil), @@ -1817,7 +2008,7 @@ ], meta=nil), ], - meta=i.Meta(mid86, 1)), + meta=i.Meta(mid98, 1)), i.Invoke(args=[ # (def pixie.stdlib/reduced) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -1825,10 +2016,10 @@ i.Fn(args=[kw(u"x")],name=kw(u"reduced"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Reduced"), meta=i.Meta(mid88, 4)), - i.Lookup(kw(u"x"), meta=i.Meta(mid88, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Reduced"), meta=i.Meta(mid100, 4)), + i.Lookup(kw(u"x"), meta=i.Meta(mid100, 14)), ], - meta=i.Meta(mid88, 3)), + meta=i.Meta(mid100, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/reduced?) @@ -1837,11 +2028,11 @@ i.Fn(args=[kw(u"x")],name=kw(u"reduced?"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid89, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid89, 14)), - i.Lookup(kw(u"x"), meta=i.Meta(mid89, 22)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid101, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid101, 14)), + i.Lookup(kw(u"x"), meta=i.Meta(mid101, 22)), ], - meta=i.Meta(mid89, 3)), + meta=i.Meta(mid101, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/satisfies?) @@ -1851,70 +2042,70 @@ body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid90, 8)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid90, 20)), - i.Lookup(kw(u"p"), meta=i.Meta(mid90, 29)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid102, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid102, 20)), + i.Lookup(kw(u"p"), meta=i.Meta(mid102, 29)), ], - meta=i.Meta(mid90, 7)), + meta=i.Meta(mid102, 7)), then=i.Let(names=[kw(u"ps")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid91, 15)), - i.Lookup(kw(u"p"), meta=i.Meta(mid91, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid103, 15)), + i.Lookup(kw(u"p"), meta=i.Meta(mid103, 19)), ], - meta=i.Meta(mid91, 14)), + meta=i.Meta(mid103, 14)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid92, 12)), - i.Lookup(kw(u"ps"), meta=i.Meta(mid92, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid104, 12)), + i.Lookup(kw(u"ps"), meta=i.Meta(mid104, 16)), ], - meta=i.Meta(mid92, 11)), + meta=i.Meta(mid104, 11)), then=i.Const(true), els=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid93, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid105, 16)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid93, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid105, 21)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid93, 34)), - i.Lookup(kw(u"ps"), meta=i.Meta(mid93, 40)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid105, 34)), + i.Lookup(kw(u"ps"), meta=i.Meta(mid105, 40)), ], - meta=i.Meta(mid93, 33)), - i.Lookup(kw(u"x"), meta=i.Meta(mid93, 44)), + meta=i.Meta(mid105, 33)), + i.Lookup(kw(u"x"), meta=i.Meta(mid105, 44)), ], - meta=i.Meta(mid93, 20)), + meta=i.Meta(mid105, 20)), ], - meta=i.Meta(mid93, 15)), + meta=i.Meta(mid105, 15)), then=i.Const(nil), els=i.TailCall( args=[ - i.Lookup(kw(u"satisfies?"), meta=i.Meta(mid94, 14)), + i.Lookup(kw(u"satisfies?"), meta=i.Meta(mid106, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid94, 26)), - i.Lookup(kw(u"ps"), meta=i.Meta(mid94, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid106, 26)), + i.Lookup(kw(u"ps"), meta=i.Meta(mid106, 31)), ], - meta=i.Meta(mid94, 25)), - i.Lookup(kw(u"x"), meta=i.Meta(mid94, 35)), + meta=i.Meta(mid106, 25)), + i.Lookup(kw(u"x"), meta=i.Meta(mid106, 35)), ], - meta=i.Meta(mid94, 13)), - meta=i.Meta(mid93, 11)), - meta=i.Meta(mid92, 7)), - meta=i.Meta(mid91, 5)), + meta=i.Meta(mid106, 13)), + meta=i.Meta(mid105, 11)), + meta=i.Meta(mid104, 7)), + meta=i.Meta(mid103, 5)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid95, 6)), - i.Lookup(kw(u"p"), meta=i.Meta(mid95, 18)), - i.Lookup(kw(u"x"), meta=i.Meta(mid95, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid107, 6)), + i.Lookup(kw(u"p"), meta=i.Meta(mid107, 18)), + i.Lookup(kw(u"x"), meta=i.Meta(mid107, 20)), ], - meta=i.Meta(mid95, 5)), - meta=i.Meta(mid90, 3)), + meta=i.Meta(mid107, 5)), + meta=i.Meta(mid102, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/transduce) @@ -1926,80 +2117,80 @@ bindings=[ i.Invoke( args=[ - i.Lookup(kw(u"xform"), meta=i.Meta(mid96, 13)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid96, 19)), + i.Lookup(kw(u"xform"), meta=i.Meta(mid108, 13)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid108, 19)), ], - meta=i.Meta(mid96, 12)), + meta=i.Meta(mid108, 12)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid97, 18)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid97, 26)), - i.Lookup(kw(u"f"), meta=i.Meta(mid97, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid109, 18)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid109, 26)), + i.Lookup(kw(u"f"), meta=i.Meta(mid109, 31)), i.Invoke( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid97, 34)), + i.Lookup(kw(u"f"), meta=i.Meta(mid109, 34)), ], - meta=i.Meta(mid97, 33)), + meta=i.Meta(mid109, 33)), ], - meta=i.Meta(mid97, 17)), + meta=i.Meta(mid109, 17)), ], body=i.TailCall( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid98, 7)), - i.Lookup(kw(u"result"), meta=i.Meta(mid98, 9)), + i.Lookup(kw(u"f"), meta=i.Meta(mid110, 7)), + i.Lookup(kw(u"result"), meta=i.Meta(mid110, 9)), ], - meta=i.Meta(mid98, 6)), - meta=i.Meta(mid96, 4)), + meta=i.Meta(mid110, 6)), + meta=i.Meta(mid108, 4)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"f"),kw(u"coll")],name=kw(u"transduce"), body=i.Let(names=[kw(u"result")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid99, 18)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid99, 26)), - i.Lookup(kw(u"f"), meta=i.Meta(mid99, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid111, 18)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid111, 26)), + i.Lookup(kw(u"f"), meta=i.Meta(mid111, 31)), i.Invoke( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid99, 34)), + i.Lookup(kw(u"f"), meta=i.Meta(mid111, 34)), ], - meta=i.Meta(mid99, 33)), + meta=i.Meta(mid111, 33)), ], - meta=i.Meta(mid99, 17)), + meta=i.Meta(mid111, 17)), ], body=i.TailCall( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid100, 7)), - i.Lookup(kw(u"result"), meta=i.Meta(mid100, 9)), + i.Lookup(kw(u"f"), meta=i.Meta(mid112, 7)), + i.Lookup(kw(u"result"), meta=i.Meta(mid112, 9)), ], - meta=i.Meta(mid100, 6)), - meta=i.Meta(mid99, 4)), + meta=i.Meta(mid112, 6)), + meta=i.Meta(mid111, 4)), ), i.Const(rt.wrap(4)), i.Fn(args=[kw(u"xform"),kw(u"rf"),kw(u"init"),kw(u"coll")],name=kw(u"transduce"), body=i.Let(names=[kw(u"f"),kw(u"result")], bindings=[ i.Invoke( args=[ - i.Lookup(kw(u"xform"), meta=i.Meta(mid101, 13)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid101, 19)), + i.Lookup(kw(u"xform"), meta=i.Meta(mid113, 13)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid113, 19)), ], - meta=i.Meta(mid101, 12)), + meta=i.Meta(mid113, 12)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid102, 18)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid102, 26)), - i.Lookup(kw(u"f"), meta=i.Meta(mid102, 31)), - i.Lookup(kw(u"init"), meta=i.Meta(mid102, 33)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid114, 18)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid114, 26)), + i.Lookup(kw(u"f"), meta=i.Meta(mid114, 31)), + i.Lookup(kw(u"init"), meta=i.Meta(mid114, 33)), ], - meta=i.Meta(mid102, 17)), + meta=i.Meta(mid114, 17)), ], body=i.TailCall( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid103, 7)), - i.Lookup(kw(u"result"), meta=i.Meta(mid103, 9)), + i.Lookup(kw(u"f"), meta=i.Meta(mid115, 7)), + i.Lookup(kw(u"result"), meta=i.Meta(mid115, 9)), ], - meta=i.Meta(mid103, 6)), - meta=i.Meta(mid101, 4)), + meta=i.Meta(mid115, 6)), + meta=i.Meta(mid113, 4)), ), ])]), i.Invoke(args=[ @@ -2010,26 +2201,26 @@ i.Const(rt.wrap(3)), i.Fn(args=[kw(u"rf"),kw(u"init"),kw(u"col")],name=kw(u"reduce"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid104, 5)), - i.Lookup(kw(u"col"), meta=i.Meta(mid104, 13)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid104, 17)), - i.Lookup(kw(u"init"), meta=i.Meta(mid104, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid116, 5)), + i.Lookup(kw(u"col"), meta=i.Meta(mid116, 13)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid116, 17)), + i.Lookup(kw(u"init"), meta=i.Meta(mid116, 20)), ], - meta=i.Meta(mid104, 4)), + meta=i.Meta(mid116, 4)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"rf"),kw(u"col")],name=kw(u"reduce"), body=i.TailCall( args=[ - i.Lookup(kw(u"reduce"), meta=i.Meta(mid105, 5)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid105, 12)), + i.Lookup(kw(u"reduce"), meta=i.Meta(mid117, 5)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid117, 12)), i.Invoke( args=[ - i.Lookup(kw(u"rf"), meta=i.Meta(mid105, 16)), + i.Lookup(kw(u"rf"), meta=i.Meta(mid117, 16)), ], - meta=i.Meta(mid105, 15)), - i.Lookup(kw(u"col"), meta=i.Meta(mid105, 20)), + meta=i.Meta(mid117, 15)), + i.Lookup(kw(u"col"), meta=i.Meta(mid117, 20)), ], - meta=i.Meta(mid105, 4)), + meta=i.Meta(mid117, 4)), ), ])]), i.Invoke(args=[ @@ -2041,72 +2232,72 @@ body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid106, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid106, 20)), - i.Lookup(kw(u"to"), meta=i.Meta(mid106, 33)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid118, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid118, 20)), + i.Lookup(kw(u"to"), meta=i.Meta(mid118, 33)), ], - meta=i.Meta(mid106, 8)), + meta=i.Meta(mid118, 8)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid107, 7)), - i.Lookup(kw(u"xform"), meta=i.Meta(mid107, 17)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid107, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid119, 7)), + i.Lookup(kw(u"xform"), meta=i.Meta(mid119, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid119, 23)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid107, 30)), - i.Lookup(kw(u"to"), meta=i.Meta(mid107, 40)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid119, 30)), + i.Lookup(kw(u"to"), meta=i.Meta(mid119, 40)), ], - meta=i.Meta(mid107, 29)), - i.Lookup(kw(u"from"), meta=i.Meta(mid107, 44)), + meta=i.Meta(mid119, 29)), + i.Lookup(kw(u"from"), meta=i.Meta(mid119, 44)), ], - meta=i.Meta(mid107, 6)), + meta=i.Meta(mid119, 6)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid108, 7)), - i.Lookup(kw(u"xform"), meta=i.Meta(mid108, 17)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid108, 23)), - i.Lookup(kw(u"to"), meta=i.Meta(mid108, 28)), - i.Lookup(kw(u"from"), meta=i.Meta(mid108, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid120, 7)), + i.Lookup(kw(u"xform"), meta=i.Meta(mid120, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid120, 23)), + i.Lookup(kw(u"to"), meta=i.Meta(mid120, 28)), + i.Lookup(kw(u"from"), meta=i.Meta(mid120, 31)), ], - meta=i.Meta(mid108, 6)), - meta=i.Meta(mid106, 4)), + meta=i.Meta(mid120, 6)), + meta=i.Meta(mid118, 4)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"to"),kw(u"from")],name=kw(u"into"), body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid109, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid109, 20)), - i.Lookup(kw(u"to"), meta=i.Meta(mid109, 33)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid121, 9)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid121, 20)), + i.Lookup(kw(u"to"), meta=i.Meta(mid121, 33)), ], - meta=i.Meta(mid109, 8)), + meta=i.Meta(mid121, 8)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"persistent!"), meta=i.Meta(mid110, 7)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"persistent!"), meta=i.Meta(mid122, 7)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid110, 20)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid110, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid122, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid122, 27)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid110, 34)), - i.Lookup(kw(u"to"), meta=i.Meta(mid110, 44)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid122, 34)), + i.Lookup(kw(u"to"), meta=i.Meta(mid122, 44)), ], - meta=i.Meta(mid110, 33)), - i.Lookup(kw(u"from"), meta=i.Meta(mid110, 48)), + meta=i.Meta(mid122, 33)), + i.Lookup(kw(u"from"), meta=i.Meta(mid122, 48)), ], - meta=i.Meta(mid110, 19)), + meta=i.Meta(mid122, 19)), ], - meta=i.Meta(mid110, 6)), + meta=i.Meta(mid122, 6)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid111, 7)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid111, 14)), - i.Lookup(kw(u"to"), meta=i.Meta(mid111, 19)), - i.Lookup(kw(u"from"), meta=i.Meta(mid111, 22)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid123, 7)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid123, 14)), + i.Lookup(kw(u"to"), meta=i.Meta(mid123, 19)), + i.Lookup(kw(u"from"), meta=i.Meta(mid123, 22)), ], - meta=i.Meta(mid111, 6)), - meta=i.Meta(mid109, 4)), + meta=i.Meta(mid123, 6)), + meta=i.Meta(mid121, 4)), ), ])]), i.Invoke(args=[ @@ -2115,36 +2306,36 @@ i.Const(code.intern_var(u"pixie.stdlib",u"map")), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"map")), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"f")],name=kw(u"map"), - body=i.Fn(args=[kw(u"xf")],name=kw(u"fn_452"),closed_overs=[kw(u"f")], - body=i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"fn_456")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"fn_456"),closed_overs=[kw(u"xf")], + body=i.Fn(args=[kw(u"xf")],name=kw(u"fn_476"),closed_overs=[kw(u"f")], + body=i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"fn_480")), + i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"fn_480"),closed_overs=[kw(u"xf")], body=i.TailCall( args=[ - i.Lookup(kw(u"xf"), meta=i.Meta(mid112, 13)), + i.Lookup(kw(u"xf"), meta=i.Meta(mid124, 13)), ], - meta=i.Meta(mid112, 12)), + meta=i.Meta(mid124, 12)), ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"result")],name=kw(u"fn_456"),closed_overs=[kw(u"xf")], + i.Const(rt.wrap(1)), i.Fn(args=[kw(u"result")],name=kw(u"fn_480"),closed_overs=[kw(u"xf")], body=i.TailCall( args=[ - i.Lookup(kw(u"xf"), meta=i.Meta(mid113, 19)), - i.Lookup(kw(u"result"), meta=i.Meta(mid113, 22)), + i.Lookup(kw(u"xf"), meta=i.Meta(mid125, 19)), + i.Lookup(kw(u"result"), meta=i.Meta(mid125, 22)), ], - meta=i.Meta(mid113, 18)), + meta=i.Meta(mid125, 18)), ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"result"),kw(u"item")],name=kw(u"fn_456"),closed_overs=[kw(u"xf"),kw(u"f")], + i.Const(rt.wrap(2)), i.Fn(args=[kw(u"result"),kw(u"item")],name=kw(u"fn_480"),closed_overs=[kw(u"xf"),kw(u"f")], body=i.TailCall( args=[ - i.Lookup(kw(u"xf"), meta=i.Meta(mid114, 24)), - i.Lookup(kw(u"result"), meta=i.Meta(mid114, 27)), + i.Lookup(kw(u"xf"), meta=i.Meta(mid126, 24)), + i.Lookup(kw(u"result"), meta=i.Meta(mid126, 27)), i.Invoke( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid114, 35)), - i.Lookup(kw(u"item"), meta=i.Meta(mid114, 37)), + i.Lookup(kw(u"f"), meta=i.Meta(mid126, 35)), + i.Lookup(kw(u"item"), meta=i.Meta(mid126, 37)), ], - meta=i.Meta(mid114, 34)), + meta=i.Meta(mid126, 34)), ], - meta=i.Meta(mid114, 23)), + meta=i.Meta(mid126, 23)), ), ]), ), @@ -2152,53 +2343,53 @@ i.Const(rt.wrap(2)), i.Fn(args=[kw(u"f"),kw(u"coll")],name=kw(u"map"),closed_overs=[kw(u"map")], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid115, 5)), - i.Fn(args=[],name=kw(u"fn_457"),closed_overs=[kw(u"map"),kw(u"f"),kw(u"coll")], + i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid127, 5)), + i.Fn(args=[],name=kw(u"fn_481"),closed_overs=[kw(u"map"),kw(u"f"),kw(u"coll")], body=i.Let(names=[kw(u"s")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid116, 16)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid116, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid128, 16)), + i.Lookup(kw(u"coll"), meta=i.Meta(mid128, 20)), ], - meta=i.Meta(mid116, 15)), + meta=i.Meta(mid128, 15)), ], body=i.If( - test=i.Lookup(kw(u"s"), meta=i.Meta(mid117, 13)), + test=i.Lookup(kw(u"s"), meta=i.Meta(mid129, 13)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid118, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid130, 12)), i.Invoke( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid118, 18)), + i.Lookup(kw(u"f"), meta=i.Meta(mid130, 18)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid118, 21)), - i.Lookup(kw(u"s"), meta=i.Meta(mid118, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid130, 21)), + i.Lookup(kw(u"s"), meta=i.Meta(mid130, 27)), ], - meta=i.Meta(mid118, 20)), + meta=i.Meta(mid130, 20)), ], - meta=i.Meta(mid118, 17)), + meta=i.Meta(mid130, 17)), i.Invoke( args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid119, 18)), - i.Lookup(kw(u"f"), meta=i.Meta(mid119, 22)), + i.Lookup(kw(u"map"), meta=i.Meta(mid131, 18)), + i.Lookup(kw(u"f"), meta=i.Meta(mid131, 22)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid119, 25)), - i.Lookup(kw(u"s"), meta=i.Meta(mid119, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid131, 25)), + i.Lookup(kw(u"s"), meta=i.Meta(mid131, 30)), ], - meta=i.Meta(mid119, 24)), + meta=i.Meta(mid131, 24)), ], - meta=i.Meta(mid119, 17)), + meta=i.Meta(mid131, 17)), ], - meta=i.Meta(mid118, 11)), + meta=i.Meta(mid130, 11)), els=i.Const(nil), - meta=i.Meta(mid117, 9)), - meta=i.Meta(mid116, 7)), + meta=i.Meta(mid129, 9)), + meta=i.Meta(mid128, 7)), ), ], - meta=i.Meta(mid115, 4)), + meta=i.Meta(mid127, 4)), ), i.Const(rt.wrap(-1)), i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(1)), @@ -2208,91 +2399,92 @@ i.Fn(args=[kw(u"cs")],name=kw(u"step"),closed_overs=[kw(u"step"),kw(u"map")], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid120, 18)), - i.Fn(args=[],name=kw(u"fn_459"),closed_overs=[kw(u"step"),kw(u"map"),kw(u"cs")], + i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid132, 18)), + i.Fn(args=[],name=kw(u"fn_483"),closed_overs=[kw(u"step"),kw(u"map"),kw(u"cs")], body=i.Let(names=[kw(u"ss")], bindings=[ i.Invoke( args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid121, 30)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid121, 34)), - i.Lookup(kw(u"cs"), meta=i.Meta(mid121, 38)), + i.Lookup(kw(u"map"), meta=i.Meta(mid133, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid133, 34)), + i.Lookup(kw(u"cs"), meta=i.Meta(mid133, 38)), ], - meta=i.Meta(mid121, 29)), + meta=i.Meta(mid133, 29)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"every?"), meta=i.Meta(mid122, 27)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"identity"), meta=i.Meta(mid122, 34)), - i.Lookup(kw(u"ss"), meta=i.Meta(mid122, 43)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"every?"), meta=i.Meta(mid134, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"identity"), meta=i.Meta(mid134, 34)), + i.Lookup(kw(u"ss"), meta=i.Meta(mid134, 43)), ], - meta=i.Meta(mid122, 26)), + meta=i.Meta(mid134, 26)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid123, 25)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid135, 25)), i.Invoke( args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid123, 31)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid123, 35)), - i.Lookup(kw(u"ss"), meta=i.Meta(mid123, 41)), + i.Lookup(kw(u"map"), meta=i.Meta(mid135, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid135, 35)), + i.Lookup(kw(u"ss"), meta=i.Meta(mid135, 41)), ], - meta=i.Meta(mid123, 30)), + meta=i.Meta(mid135, 30)), i.Invoke( args=[ - i.Lookup(kw(u"step"), meta=i.Meta(mid123, 46)), + i.Lookup(kw(u"step"), meta=i.Meta(mid135, 46)), i.Invoke( args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid123, 52)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid123, 56)), - i.Lookup(kw(u"ss"), meta=i.Meta(mid123, 61)), + i.Lookup(kw(u"map"), meta=i.Meta(mid135, 52)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid135, 56)), + i.Lookup(kw(u"ss"), meta=i.Meta(mid135, 61)), ], - meta=i.Meta(mid123, 51)), + meta=i.Meta(mid135, 51)), ], - meta=i.Meta(mid123, 45)), + meta=i.Meta(mid135, 45)), ], - meta=i.Meta(mid123, 24)), + meta=i.Meta(mid135, 24)), els=i.Const(nil), - meta=i.Meta(mid122, 22)), - meta=i.Meta(mid121, 20)), + meta=i.Meta(mid134, 22)), + meta=i.Meta(mid133, 20)), ), ], - meta=i.Meta(mid120, 17)), + meta=i.Meta(mid132, 17)), ), ], body=i.TailCall( args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid124, 7)), - i.Fn(args=[kw(u"args")],name=kw(u"fn_461"),closed_overs=[kw(u"f")], + i.Lookup(kw(u"map"), meta=i.Meta(mid136, 7)), + i.Fn(args=[kw(u"args")],name=kw(u"fn_485"),closed_overs=[kw(u"f")], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid124, 23)), - i.Lookup(kw(u"f"), meta=i.Meta(mid124, 29)), - i.Lookup(kw(u"args"), meta=i.Meta(mid124, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid136, 23)), + i.Lookup(kw(u"f"), meta=i.Meta(mid136, 29)), + i.Lookup(kw(u"args"), meta=i.Meta(mid136, 31)), ], - meta=i.Meta(mid124, 22)), + meta=i.Meta(mid136, 22)), ), i.Invoke( args=[ - i.Lookup(kw(u"step"), meta=i.Meta(mid124, 39)), - i.Lookup(kw(u"colls"), meta=i.Meta(mid124, 44)), + i.Lookup(kw(u"step"), meta=i.Meta(mid136, 39)), + i.Lookup(kw(u"colls"), meta=i.Meta(mid136, 44)), ], - meta=i.Meta(mid124, 38)), + meta=i.Meta(mid136, 38)), ], - meta=i.Meta(mid124, 6)), - meta=i.Meta(mid125, 4)), + meta=i.Meta(mid136, 6)), + meta=i.Meta(mid137, 4)), )]) ])]), + i.Const(nil), i.Do( args=[ i.Invoke(args=[ -# (def pixie.stdlib/Range) +# (def pixie.stdlib.range/Range) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"Range")), + i.Const(code.intern_var(u"pixie.stdlib.range",u"Range")), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"Range")), + i.Const(kw(u"pixie.stdlib.range.Range")), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"start")), i.Const(kw(u"stop")), @@ -2301,14 +2493,14 @@ ], meta=nil)]), i.Invoke(args=[ -# (def pixie.stdlib/->Range) +# (def pixie.stdlib.range/->Range) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"->Range")), + i.Const(code.intern_var(u"pixie.stdlib.range",u"->Range")), i.Fn(args=[kw(u"start"),kw(u"stop"),kw(u"step")],name=kw(u"->Range"), body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=i.Meta(mid138, 10)), i.Lookup(kw(u"start"), meta=nil), i.Lookup(kw(u"stop"), meta=nil), i.Lookup(kw(u"step"), meta=nil), @@ -2318,193 +2510,177 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid127, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid139, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"self"),kw(u"f"),kw(u"init")],name=kw(u"-reduce_Range"), body=i.Let(names=[kw(u"i"),kw(u"acc")], bindings=[ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), i.Const(kw(u"start")), ], meta=nil), - i.Lookup(kw(u"init"), meta=i.Meta(mid128, 16)), + i.Lookup(kw(u"init"), meta=i.Meta(mid140, 16)), ], body=i.TailCall( args=[ i.Fn(args=[kw(u"i"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"self"),kw(u"f")], body=i.Let(names=[kw(u"i"),kw(u"acc")], bindings=[ - i.Lookup(kw(u"i"), meta=i.Meta(mid129, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid128, 12)), + i.Lookup(kw(u"i"), meta=i.Meta(mid141, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid140, 12)), ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid130, 8)), - i.Lookup(kw(u"i"), meta=i.Meta(mid130, 16)), - ], - meta=i.Meta(mid130, 7)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid131, 8)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid131, 16)), - ], - meta=i.Meta(mid131, 7)), + body=i.If( + test=i.Let(names=[kw(u"r#__gensym_321")], + bindings=[ i.If( - test=i.Let(names=[kw(u"r#__gensym_321")], + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid142, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), + i.Const(kw(u"step")), + ], + meta=nil), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid142, 20)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid142, 32)), + i.Lookup(kw(u"i"), meta=i.Meta(mid142, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), + i.Const(kw(u"stop")), + ], + meta=nil), + ], + meta=i.Meta(mid142, 31)), + els=i.Const(nil), + meta=i.Meta(mid142, 15)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_321"), meta=nil), + els=i.Let(names=[kw(u"r#__gensym_320")], bindings=[ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid132, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid143, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid132, 20)), + meta=i.Meta(mid143, 20)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid132, 32)), - i.Lookup(kw(u"i"), meta=i.Meta(mid132, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid143, 32)), + i.Lookup(kw(u"i"), meta=i.Meta(mid143, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid132, 31)), + meta=i.Meta(mid143, 31)), els=i.Const(nil), - meta=i.Meta(mid132, 15)), + meta=i.Meta(mid143, 15)), ], body=i.If( - test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_321"), meta=nil), - els=i.Let(names=[kw(u"r#__gensym_320")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid133, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid133, 20)), - then=i.Invoke( + test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid144, 21)), + i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid133, 32)), - i.Lookup(kw(u"i"), meta=i.Meta(mid133, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), - i.Const(kw(u"stop")), - ], - meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), + i.Const(kw(u"step")), ], - meta=i.Meta(mid133, 31)), - els=i.Const(nil), - meta=i.Meta(mid133, 15)), + meta=nil), + i.Const(rt.wrap(0)), ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid134, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid134, 15)), - meta=nil), - meta=nil), + meta=i.Meta(mid144, 15)), meta=nil), - meta=i.Meta(mid132, 11)), - then=i.Let(names=[kw(u"acc")], - bindings=[ - i.Invoke( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid135, 20)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid135, 22)), - i.Lookup(kw(u"i"), meta=i.Meta(mid135, 26)), - ], - meta=i.Meta(mid135, 19)), + meta=nil), + meta=nil), + meta=i.Meta(mid142, 11)), + then=i.Let(names=[kw(u"acc")], + bindings=[ + i.Invoke( + args=[ + i.Lookup(kw(u"f"), meta=i.Meta(mid145, 20)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid145, 22)), + i.Lookup(kw(u"i"), meta=i.Meta(mid145, 26)), + ], + meta=i.Meta(mid145, 19)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid146, 16)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid146, 25)), ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid136, 16)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid136, 25)), - ], - meta=i.Meta(mid136, 15)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), - i.Lookup(kw(u"acc"), meta=i.Meta(mid137, 14)), - ], - meta=i.Meta(mid137, 13)), - els=i.TailCall( + meta=i.Meta(mid146, 15)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), + i.Lookup(kw(u"acc"), meta=i.Meta(mid147, 14)), + ], + meta=i.Meta(mid147, 13)), + els=i.TailCall( + args=[ + i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), + i.Invoke( args=[ - i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid148, 21)), + i.Lookup(kw(u"i"), meta=i.Meta(mid148, 23)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid138, 21)), - i.Lookup(kw(u"i"), meta=i.Meta(mid138, 23)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid127, 13)), - i.Const(kw(u"step")), - ], - meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), + i.Const(kw(u"step")), ], - meta=i.Meta(mid138, 20)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid138, 31)), + meta=nil), ], - meta=nil), - meta=i.Meta(mid136, 11)), - meta=i.Meta(mid135, 9)), - els=i.Lookup(kw(u"acc"), meta=i.Meta(mid139, 9)), - meta=i.Meta(mid132, 7)), - ], - meta=nil), + meta=i.Meta(mid148, 20)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid148, 31)), + ], + meta=nil), + meta=i.Meta(mid146, 11)), + meta=i.Meta(mid145, 9)), + els=i.Lookup(kw(u"acc"), meta=i.Meta(mid149, 9)), + meta=i.Meta(mid142, 7)), meta=nil), ), - i.Lookup(kw(u"i"), meta=i.Meta(mid129, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid128, 12)), + i.Lookup(kw(u"i"), meta=i.Meta(mid141, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid140, 12)), ], meta=nil), - meta=i.Meta(mid129, 5)), + meta=i.Meta(mid141, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid140, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid150, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"self")],name=kw(u"-count_Range"), body=i.If( test=i.Let(names=[kw(u"r#__gensym_321")], @@ -2512,38 +2688,38 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid141, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid151, 19)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid141, 18)), + meta=i.Meta(mid151, 18)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid141, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid151, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid141, 33)), + meta=i.Meta(mid151, 33)), els=i.Const(nil), - meta=i.Meta(mid141, 13)), + meta=i.Meta(mid151, 13)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), @@ -2553,105 +2729,105 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid142, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid152, 19)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid142, 18)), + meta=i.Meta(mid152, 18)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid142, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid152, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid142, 33)), + meta=i.Meta(mid152, 33)), els=i.Const(nil), - meta=i.Meta(mid142, 13)), + meta=i.Meta(mid152, 13)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), els=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid143, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid153, 14)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid143, 13)), + meta=i.Meta(mid153, 13)), meta=nil), meta=nil), meta=nil), - meta=i.Meta(mid141, 9)), + meta=i.Meta(mid151, 9)), then=i.Const(rt.wrap(0)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"abs"), meta=i.Meta(mid144, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"abs"), meta=i.Meta(mid154, 8)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"quot"), meta=i.Meta(mid144, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"quot"), meta=i.Meta(mid154, 13)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid144, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid154, 19)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid144, 18)), + meta=i.Meta(mid154, 18)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid140, 12)), + i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid144, 12)), + meta=i.Meta(mid154, 12)), ], - meta=i.Meta(mid144, 7)), - meta=i.Meta(mid141, 5)), + meta=i.Meta(mid154, 7)), + meta=i.Meta(mid151, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid145, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid155, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"self"),kw(u"idx")],name=kw(u"-nth_Range"), body=i.Do( args=[ @@ -2660,124 +2836,124 @@ bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid146, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid156, 16)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), i.Const(kw(u"stop")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid146, 15)), + meta=i.Meta(mid156, 15)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), els=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"neg?"), meta=i.Meta(mid146, 33)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid146, 38)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"neg?"), meta=i.Meta(mid156, 33)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid156, 38)), ], - meta=i.Meta(mid146, 32)), + meta=i.Meta(mid156, 32)), meta=nil), - meta=i.Meta(mid146, 11)), + meta=i.Meta(mid156, 11)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid147, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid157, 8)), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), i.Const(rt.wrap(u"Index out of Range")), ]), ], - meta=i.Meta(mid147, 7)), + meta=i.Meta(mid157, 7)), els=i.Const(nil), - meta=i.Meta(mid146, 5)), + meta=i.Meta(mid156, 5)), i.Let(names=[kw(u"cmp"),kw(u"val")], bindings=[ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid158, 20)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid148, 19)), - then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid148, 34)), - els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid148, 36)), - meta=i.Meta(mid148, 15)), + meta=i.Meta(mid158, 19)), + then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid158, 34)), + els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid158, 36)), + meta=i.Meta(mid158, 15)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid149, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid159, 16)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid149, 25)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid149, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid159, 25)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid159, 27)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid149, 24)), + meta=i.Meta(mid159, 24)), ], - meta=i.Meta(mid149, 15)), + meta=i.Meta(mid159, 15)), ], body=i.If( test=i.Invoke( args=[ - i.Lookup(kw(u"cmp"), meta=i.Meta(mid150, 12)), - i.Lookup(kw(u"val"), meta=i.Meta(mid150, 16)), + i.Lookup(kw(u"cmp"), meta=i.Meta(mid160, 12)), + i.Lookup(kw(u"val"), meta=i.Meta(mid160, 16)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid145, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid150, 11)), - then=i.Lookup(kw(u"val"), meta=i.Meta(mid151, 9)), + meta=i.Meta(mid160, 11)), + then=i.Lookup(kw(u"val"), meta=i.Meta(mid161, 9)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid152, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid162, 10)), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), i.Const(rt.wrap(u"Index out of Range")), ]), ], - meta=i.Meta(mid152, 9)), - meta=i.Meta(mid150, 7)), - meta=i.Meta(mid148, 5)), + meta=i.Meta(mid162, 9)), + meta=i.Meta(mid160, 7)), + meta=i.Meta(mid158, 5)), ], meta=nil), ), @@ -2786,86 +2962,86 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid153, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid163, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"self"),kw(u"idx"),kw(u"not-found")],name=kw(u"-nth-not-found_Range"), body=i.Let(names=[kw(u"cmp"),kw(u"val")], bindings=[ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid154, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid164, 20)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid154, 19)), - then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid154, 34)), - els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid154, 36)), - meta=i.Meta(mid154, 15)), + meta=i.Meta(mid164, 19)), + then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid164, 34)), + els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid164, 36)), + meta=i.Meta(mid164, 15)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid155, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid165, 16)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid155, 25)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid155, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid165, 25)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid165, 27)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid155, 24)), + meta=i.Meta(mid165, 24)), ], - meta=i.Meta(mid155, 15)), + meta=i.Meta(mid165, 15)), ], body=i.If( test=i.Invoke( args=[ - i.Lookup(kw(u"cmp"), meta=i.Meta(mid156, 12)), - i.Lookup(kw(u"val"), meta=i.Meta(mid156, 16)), + i.Lookup(kw(u"cmp"), meta=i.Meta(mid166, 12)), + i.Lookup(kw(u"val"), meta=i.Meta(mid166, 16)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid153, 20)), + i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid156, 11)), - then=i.Lookup(kw(u"val"), meta=i.Meta(mid157, 9)), - els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid158, 8)), - meta=i.Meta(mid156, 7)), - meta=i.Meta(mid154, 5)), + meta=i.Meta(mid166, 11)), + then=i.Lookup(kw(u"val"), meta=i.Meta(mid167, 9)), + els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid168, 8)), + meta=i.Meta(mid166, 7)), + meta=i.Meta(mid164, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid159, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid169, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"self")],name=kw(u"-seq_Range"), body=i.If( test=i.Let(names=[kw(u"r#__gensym_320")], @@ -2873,38 +3049,38 @@ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid160, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid170, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid160, 20)), + meta=i.Meta(mid170, 20)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid160, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid170, 32)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid160, 31)), + meta=i.Meta(mid170, 31)), els=i.Const(nil), - meta=i.Meta(mid160, 15)), + meta=i.Meta(mid170, 15)), ], body=i.If( test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), @@ -2912,161 +3088,162 @@ els=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid161, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid171, 21)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"step")), ], meta=nil), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid161, 20)), + meta=i.Meta(mid171, 20)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid161, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid171, 32)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"stop")), ], meta=nil), ], - meta=i.Meta(mid161, 31)), + meta=i.Meta(mid171, 31)), els=i.Const(nil), - meta=i.Meta(mid161, 15)), + meta=i.Meta(mid171, 15)), meta=nil), - meta=i.Meta(mid160, 11)), + meta=i.Meta(mid170, 11)), then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid162, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid172, 8)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid162, 20)), - i.Fn(args=[],name=kw(u"fn_480"),closed_overs=[kw(u"self")], + i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid172, 20)), + i.Fn(args=[],name=kw(u"fn_504"),closed_overs=[kw(u"self")], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid162, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid172, 32)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid162, 39)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid172, 39)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"start")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid162, 38)), + meta=i.Meta(mid172, 38)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"stop")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid159, 10)), + i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), i.Const(kw(u"step")), ], meta=nil), ], - meta=i.Meta(mid162, 31)), + meta=i.Meta(mid172, 31)), ), ], - meta=i.Meta(mid162, 19)), + meta=i.Meta(mid172, 19)), ], - meta=i.Meta(mid162, 7)), + meta=i.Meta(mid172, 7)), els=i.Const(nil), - meta=i.Meta(mid160, 5)), + meta=i.Meta(mid170, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid163, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid173, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-str_Range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid164, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid174, 6)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid164, 12)), - i.Lookup(kw(u"this"), meta=i.Meta(mid164, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid174, 12)), + i.Lookup(kw(u"this"), meta=i.Meta(mid174, 16)), ], - meta=i.Meta(mid164, 11)), - i.Lookup(kw(u"sbf"), meta=i.Meta(mid164, 22)), + meta=i.Meta(mid174, 11)), + i.Lookup(kw(u"sbf"), meta=i.Meta(mid174, 22)), ], - meta=i.Meta(mid164, 5)), + meta=i.Meta(mid174, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid165, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid175, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-repr_Range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid166, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid176, 6)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid166, 13)), - i.Lookup(kw(u"this"), meta=i.Meta(mid166, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid176, 13)), + i.Lookup(kw(u"this"), meta=i.Meta(mid176, 17)), ], - meta=i.Meta(mid166, 12)), - i.Lookup(kw(u"sbf"), meta=i.Meta(mid166, 23)), + meta=i.Meta(mid176, 12)), + i.Lookup(kw(u"sbf"), meta=i.Meta(mid176, 23)), ], - meta=i.Meta(mid166, 5)), + meta=i.Meta(mid176, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid167, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Range"), meta=i.Meta(mid126, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid177, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"-eq_Range"), - body=i.VDeref(code.intern_var(u"pixie.stdlib", u"do"), meta=i.Meta(mid168, 25)), + body=i.Const(nil), ), ], meta=nil), ], - meta=i.Meta(mid126, 1)), + meta=i.Meta(mid138, 1)), i.Invoke(args=[ -# (def pixie.stdlib/MAX-NUMBER) +# (def pixie.stdlib.range/MAX-NUMBER) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"MAX-NUMBER")), + i.Const(code.intern_var(u"pixie.stdlib.range",u"MAX-NUMBER")), i.Const(rt.wrap(4294967295))]), + i.Const(nil), i.Invoke(args=[ # (def pixie.stdlib/range) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -3075,42 +3252,42 @@ i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid169, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid178, 8)), i.Const(rt.wrap(0)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"MAX-NUMBER"), meta=i.Meta(mid169, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"MAX-NUMBER"), meta=i.Meta(mid178, 37)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid169, 7)), + meta=i.Meta(mid178, 7)), ), i.Const(rt.wrap(1)), i.Fn(args=[kw(u"stop")],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid170, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid179, 12)), i.Const(rt.wrap(0)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid170, 22)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid179, 41)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid170, 11)), + meta=i.Meta(mid179, 11)), ), i.Const(rt.wrap(3)), i.Fn(args=[kw(u"start"),kw(u"stop"),kw(u"step")],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid171, 23)), - i.Lookup(kw(u"start"), meta=i.Meta(mid171, 31)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid171, 37)), - i.Lookup(kw(u"step"), meta=i.Meta(mid171, 42)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid180, 23)), + i.Lookup(kw(u"start"), meta=i.Meta(mid180, 50)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid180, 56)), + i.Lookup(kw(u"step"), meta=i.Meta(mid180, 61)), ], - meta=i.Meta(mid171, 22)), + meta=i.Meta(mid180, 22)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"start"),kw(u"stop")],name=kw(u"range"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Range"), meta=i.Meta(mid172, 18)), - i.Lookup(kw(u"start"), meta=i.Meta(mid172, 26)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid172, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid181, 18)), + i.Lookup(kw(u"start"), meta=i.Meta(mid181, 45)), + i.Lookup(kw(u"stop"), meta=i.Meta(mid181, 51)), i.Const(rt.wrap(1)), ], - meta=i.Meta(mid172, 17)), + meta=i.Meta(mid181, 17)), ), ])]), i.Do( @@ -3122,7 +3299,7 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"Node")), + i.Const(kw(u"pixie.stdlib.Node")), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"edit")), i.Const(kw(u"array")), @@ -3137,7 +3314,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid173, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid182, 10)), i.Lookup(kw(u"edit"), meta=nil), i.Lookup(kw(u"array"), meta=nil), ], @@ -3146,21 +3323,21 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid174, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid173, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid183, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=nil), i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_Node"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid175, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid175, 16)), - i.Lookup(kw(u"name"), meta=i.Meta(mid175, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid184, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid184, 16)), + i.Lookup(kw(u"name"), meta=i.Meta(mid184, 21)), ], - meta=i.Meta(mid175, 5)), + meta=i.Meta(mid184, 5)), ), ], meta=nil), ], - meta=i.Meta(mid173, 1)), + meta=i.Meta(mid182, 1)), i.Invoke(args=[ # (def pixie.stdlib/new-node) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -3169,25 +3346,25 @@ i.Const(rt.wrap(1)), i.Fn(args=[kw(u"edit")],name=kw(u"new-node"), body=i.TailCall( args=[ - i.Lookup(kw(u"new-node"), meta=i.Meta(mid176, 5)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid176, 14)), + i.Lookup(kw(u"new-node"), meta=i.Meta(mid185, 5)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid185, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid176, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid185, 20)), i.Const(rt.wrap(32)), ], - meta=i.Meta(mid176, 19)), + meta=i.Meta(mid185, 19)), ], - meta=i.Meta(mid176, 4)), + meta=i.Meta(mid185, 4)), ), i.Const(rt.wrap(2)), i.Fn(args=[kw(u"edit"),kw(u"array")],name=kw(u"new-node"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid177, 5)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid177, 12)), - i.Lookup(kw(u"array"), meta=i.Meta(mid177, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid186, 5)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid186, 12)), + i.Lookup(kw(u"array"), meta=i.Meta(mid186, 17)), ], - meta=i.Meta(mid177, 4)), + meta=i.Meta(mid186, 4)), ), ])]), i.Invoke(args=[ @@ -3196,10 +3373,10 @@ i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY-NODE")), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid178, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid187, 18)), i.Const(nil), ], - meta=i.Meta(mid178, 17))]), + meta=i.Meta(mid187, 17))]), i.Invoke(args=[ # (def pixie.stdlib/tailoff) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -3209,147 +3386,187 @@ bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid179, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid189, 20)), i.Const(kw(u"cnt")), ], - meta=i.Meta(mid179, 13)), + meta=i.Meta(mid189, 13)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid180, 10)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid180, 12)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid190, 10)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid190, 12)), i.Const(rt.wrap(32)), ], - meta=i.Meta(mid180, 9)), + meta=i.Meta(mid190, 9)), then=i.Const(rt.wrap(0)), els=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid181, 8)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid191, 8)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid181, 24)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid191, 24)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid181, 41)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid181, 45)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid191, 41)), + i.Lookup(kw(u"cnt"), meta=i.Meta(mid191, 45)), ], - meta=i.Meta(mid181, 40)), + meta=i.Meta(mid191, 40)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid181, 23)), + meta=i.Meta(mid191, 23)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid181, 7)), - meta=i.Meta(mid180, 5)), - meta=i.Meta(mid179, 3)), + meta=i.Meta(mid191, 7)), + meta=i.Meta(mid190, 5)), + meta=i.Meta(mid189, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/array-for) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), i.Const(code.intern_var(u"pixie.stdlib",u"array-for")), - i.Fn(args=[kw(u"this"),kw(u"i"),kw(u"cnt"),kw(u"root"),kw(u"shift"),kw(u"tail")],name=kw(u"array-for"), + i.Fn(args=[kw(u"this"),kw(u"i")],name=kw(u"array-for"), body=i.If( test=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid182, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid192, 13)), i.Const(rt.wrap(0)), - i.Lookup(kw(u"i"), meta=i.Meta(mid182, 22)), + i.Lookup(kw(u"i"), meta=i.Meta(mid192, 18)), ], - meta=i.Meta(mid182, 16)), + meta=i.Meta(mid192, 12)), then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid182, 26)), - i.Lookup(kw(u"i"), meta=i.Meta(mid182, 28)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid182, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid192, 22)), + i.Lookup(kw(u"i"), meta=i.Meta(mid192, 24)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid192, 33)), + i.Const(kw(u"cnt")), + ], + meta=i.Meta(mid192, 26)), ], - meta=i.Meta(mid182, 25)), + meta=i.Meta(mid192, 21)), els=i.Const(nil), - meta=i.Meta(mid182, 11)), + meta=i.Meta(mid192, 7)), then=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">="), meta=i.Meta(mid183, 14)), - i.Lookup(kw(u"i"), meta=i.Meta(mid183, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">="), meta=i.Meta(mid193, 10)), + i.Lookup(kw(u"i"), meta=i.Meta(mid193, 13)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid183, 20)), - i.Lookup(kw(u"this"), meta=i.Meta(mid183, 28)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid193, 16)), + i.Lookup(kw(u"this"), meta=i.Meta(mid193, 24)), ], - meta=i.Meta(mid183, 19)), + meta=i.Meta(mid193, 15)), ], - meta=i.Meta(mid183, 13)), - then=i.Lookup(kw(u"tail"), meta=i.Meta(mid184, 11)), - els=i.TailCall( + meta=i.Meta(mid193, 9)), + then=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Invoke( - args=[ - i.Fn(args=[kw(u"node"),kw(u"level")],name=kw(u"look-deeper"),closed_overs=[kw(u"i")], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid185, 28)), - i.Lookup(kw(u"level"), meta=i.Meta(mid185, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid194, 15)), + i.Const(kw(u"tail")), + ], + meta=i.Meta(mid194, 7)), + els=i.Let(names=[kw(u"node"),kw(u"level")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid195, 27)), + i.Const(kw(u"root")), + ], + meta=i.Meta(mid195, 19)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid196, 29)), + i.Const(kw(u"shift")), + ], + meta=i.Meta(mid196, 20)), + ], + body=i.TailCall( + args=[ + i.Fn(args=[kw(u"node"),kw(u"level")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"i")], + body=i.Let(names=[kw(u"node"),kw(u"level")], + bindings=[ + i.Lookup(kw(u"node"), meta=i.Meta(mid195, 14)), + i.Lookup(kw(u"level"), meta=i.Meta(mid196, 14)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid197, 14)), + i.Lookup(kw(u"level"), meta=i.Meta(mid197, 16)), i.Const(rt.wrap(0)), ], - meta=i.Meta(mid185, 27)), + meta=i.Meta(mid197, 13)), then=i.TailCall( args=[ - i.Lookup(kw(u"look-deeper"), meta=i.Meta(mid186, 26)), + i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid186, 39)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid198, 19)), i.Invoke( args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"node"), meta=i.Meta(mid198, 33)), i.Const(kw(u"array")), - i.Lookup(kw(u"node"), meta=i.Meta(mid186, 52)), ], - meta=i.Meta(mid186, 44)), + meta=i.Meta(mid198, 24)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid187, 45)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid199, 25)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid187, 54)), - i.Lookup(kw(u"i"), meta=i.Meta(mid187, 70)), - i.Lookup(kw(u"level"), meta=i.Meta(mid187, 72)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid199, 34)), + i.Lookup(kw(u"i"), meta=i.Meta(mid199, 50)), + i.Lookup(kw(u"level"), meta=i.Meta(mid199, 52)), ], - meta=i.Meta(mid187, 53)), + meta=i.Meta(mid199, 33)), i.Const(rt.wrap(31)), ], - meta=i.Meta(mid187, 44)), + meta=i.Meta(mid199, 24)), ], - meta=i.Meta(mid186, 38)), + meta=i.Meta(mid198, 18)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid188, 39)), - i.Lookup(kw(u"level"), meta=i.Meta(mid188, 41)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid200, 19)), + i.Lookup(kw(u"level"), meta=i.Meta(mid200, 21)), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid188, 38)), + meta=i.Meta(mid200, 18)), ], - meta=i.Meta(mid186, 25)), + meta=nil), els=i.TailCall( args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"node"), meta=i.Meta(mid201, 20)), i.Const(kw(u"array")), - i.Lookup(kw(u"node"), meta=i.Meta(mid189, 33)), ], - meta=i.Meta(mid189, 25)), - meta=i.Meta(mid185, 23)), - ), - i.Lookup(kw(u"root"), meta=i.Meta(mid190, 21)), - i.Lookup(kw(u"shift"), meta=i.Meta(mid191, 21)), - ], - meta=i.Meta(mid192, 20)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid192, 11)), - meta=i.Meta(mid183, 9)), - els=i.Const(nil), - meta=i.Meta(mid182, 7)), + meta=i.Meta(mid201, 11)), + meta=i.Meta(mid197, 9)), + meta=nil), + ), + i.Lookup(kw(u"node"), meta=i.Meta(mid195, 14)), + i.Lookup(kw(u"level"), meta=i.Meta(mid196, 14)), + ], + meta=nil), + meta=i.Meta(mid195, 7)), + meta=i.Meta(mid193, 5)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid202, 6)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/IndexOutOfRangeException")), + i.Const(rt.wrap(u"Index out of range")), + ]), + ], + meta=i.Meta(mid202, 5)), + meta=i.Meta(mid192, 3)), )]), i.Do( args=[ @@ -3360,7 +3577,7 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"PersistentVector")), + i.Const(kw(u"pixie.stdlib.PersistentVector")), i.Invoke(args=[ i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"cnt")), i.Const(kw(u"shift")), @@ -3378,7 +3595,7 @@ body=i.TailCall( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid203, 10)), i.Lookup(kw(u"cnt"), meta=nil), i.Lookup(kw(u"shift"), meta=nil), i.Lookup(kw(u"root"), meta=nil), @@ -3390,41 +3607,41 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid194, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid204, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_PersistentVector"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid195, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid195, 16)), - i.Lookup(kw(u"name"), meta=i.Meta(mid195, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid205, 6)), + i.Lookup(kw(u"this"), meta=i.Meta(mid205, 16)), + i.Lookup(kw(u"name"), meta=i.Meta(mid205, 21)), ], - meta=i.Meta(mid195, 5)), + meta=i.Meta(mid205, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid196, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid206, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), i.Fn(args=[kw(u"this"),kw(u"val")],name=kw(u"-conj_PersistentVector"), body=i.Do( args=[ i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid197, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid207, 14)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"cnt")), ], meta=nil), i.Const(rt.wrap(4294967295)), ], - meta=i.Meta(mid197, 13)), + meta=i.Meta(mid207, 13)), then=i.Const(nil), els=i.Invoke( args=[ @@ -3441,331 +3658,338 @@ ]), ], meta=nil), - meta=i.Meta(mid197, 5)), + meta=i.Meta(mid207, 5)), i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid198, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid208, 10)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid198, 13)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid208, 13)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"cnt")), ], meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid198, 20)), - i.Lookup(kw(u"this"), meta=i.Meta(mid198, 28)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid208, 20)), + i.Lookup(kw(u"this"), meta=i.Meta(mid208, 28)), ], - meta=i.Meta(mid198, 19)), + meta=i.Meta(mid208, 19)), ], - meta=i.Meta(mid198, 12)), + meta=i.Meta(mid208, 12)), i.Const(rt.wrap(32)), ], - meta=i.Meta(mid198, 9)), + meta=i.Meta(mid208, 9)), then=i.Let(names=[kw(u"new-tail")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-append"), meta=i.Meta(mid199, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-append"), meta=i.Meta(mid209, 23)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"tail")), ], meta=nil), - i.Lookup(kw(u"val"), meta=i.Meta(mid199, 41)), + i.Lookup(kw(u"val"), meta=i.Meta(mid209, 41)), ], - meta=i.Meta(mid199, 22)), + meta=i.Meta(mid209, 22)), ], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid200, 10)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid210, 10)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid200, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid210, 30)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"cnt")), ], meta=nil), ], - meta=i.Meta(mid200, 29)), + meta=i.Meta(mid210, 29)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"shift")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"root")), ], meta=nil), - i.Lookup(kw(u"new-tail"), meta=i.Meta(mid200, 50)), + i.Lookup(kw(u"new-tail"), meta=i.Meta(mid210, 50)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"meta")), ], meta=nil), ], - meta=i.Meta(mid200, 9)), - meta=i.Meta(mid199, 7)), + meta=i.Meta(mid210, 9)), + meta=i.Meta(mid209, 7)), els=i.Let(names=[kw(u"tail-node")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid201, 24)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid211, 24)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"root")), ], meta=nil), i.Const(kw(u"edit")), ], - meta=i.Meta(mid201, 31)), + meta=i.Meta(mid211, 31)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"tail")), ], meta=nil), ], - meta=i.Meta(mid201, 23)), + meta=i.Meta(mid211, 23)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid202, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid212, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid202, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid212, 17)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"cnt")), ], meta=nil), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid202, 16)), + meta=i.Meta(mid212, 16)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid202, 41)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid212, 41)), i.Const(rt.wrap(1)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"shift")), ], meta=nil), ], - meta=i.Meta(mid202, 40)), + meta=i.Meta(mid212, 40)), ], - meta=i.Meta(mid202, 13)), - then=i.Let(names=[kw(u"new-root")], + meta=i.Meta(mid212, 13)), + then=i.Let(names=[kw(u"new-root"),kw(u"new-root-arr")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid203, 27)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid213, 27)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"root")), ], meta=nil), i.Const(kw(u"edit")), ], - meta=i.Meta(mid203, 36)), + meta=i.Meta(mid213, 36)), ], - meta=i.Meta(mid203, 26)), + meta=i.Meta(mid213, 26)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid214, 39)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid214, 30)), ], body=i.Do( args=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid204, 14)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid204, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid215, 14)), + i.Lookup(kw(u"new-root-arr"), meta=i.Meta(mid215, 19)), i.Const(rt.wrap(0)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"root")), ], meta=nil), ], - meta=i.Meta(mid204, 13)), + meta=i.Meta(mid215, 13)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid205, 14)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid205, 19)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid216, 14)), + i.Lookup(kw(u"new-root-arr"), meta=i.Meta(mid216, 19)), i.Const(rt.wrap(1)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid205, 31)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid216, 35)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"root")), ], meta=nil), i.Const(kw(u"edit")), ], - meta=i.Meta(mid205, 40)), + meta=i.Meta(mid216, 44)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"shift")), ], meta=nil), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid205, 60)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid216, 64)), ], - meta=i.Meta(mid205, 30)), + meta=i.Meta(mid216, 34)), ], - meta=i.Meta(mid205, 13)), + meta=i.Meta(mid216, 13)), i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid206, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid217, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid206, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid217, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"cnt")), ], meta=nil), ], - meta=i.Meta(mid206, 33)), + meta=i.Meta(mid217, 33)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid207, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid218, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"shift")), ], meta=nil), i.Const(rt.wrap(5)), ], - meta=i.Meta(mid207, 33)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid208, 33)), + meta=i.Meta(mid218, 33)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid219, 33)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid209, 34)), - i.Lookup(kw(u"val"), meta=i.Meta(mid209, 40)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid220, 34)), + i.Lookup(kw(u"val"), meta=i.Meta(mid220, 40)), ], - meta=i.Meta(mid209, 33)), + meta=i.Meta(mid220, 33)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"meta")), ], meta=nil), ], - meta=i.Meta(mid206, 13)), + meta=i.Meta(mid217, 13)), ], meta=nil), - meta=i.Meta(mid203, 11)), + meta=i.Meta(mid213, 11)), els=i.Let(names=[kw(u"new-root")], bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"push-tail"), meta=i.Meta(mid210, 27)), - i.Lookup(kw(u"this"), meta=i.Meta(mid210, 37)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"push-tail"), meta=i.Meta(mid221, 27)), + i.Lookup(kw(u"this"), meta=i.Meta(mid221, 37)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"shift")), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"root")), ], meta=nil), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid210, 53)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid221, 53)), ], - meta=i.Meta(mid210, 26)), + meta=i.Meta(mid221, 26)), ], body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid211, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid222, 14)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid211, 34)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid222, 34)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"cnt")), ], meta=nil), ], - meta=i.Meta(mid211, 33)), + meta=i.Meta(mid222, 33)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"shift")), ], meta=nil), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid212, 33)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid223, 33)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid213, 34)), - i.Lookup(kw(u"val"), meta=i.Meta(mid213, 40)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid224, 34)), + i.Lookup(kw(u"val"), meta=i.Meta(mid224, 40)), ], - meta=i.Meta(mid213, 33)), + meta=i.Meta(mid224, 33)), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 11)), + i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), i.Const(kw(u"meta")), ], meta=nil), ], - meta=i.Meta(mid211, 13)), - meta=i.Meta(mid210, 11)), - meta=i.Meta(mid202, 9)), - meta=i.Meta(mid201, 7)), - meta=i.Meta(mid198, 5)), + meta=i.Meta(mid222, 13)), + meta=i.Meta(mid221, 11)), + meta=i.Meta(mid212, 9)), + meta=i.Meta(mid211, 7)), + meta=i.Meta(mid208, 5)), ], meta=nil), ), @@ -3774,411 +3998,1138 @@ i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid214, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid193, 10)), - i.Fn(args=[kw(u"this")],name=kw(u"-count_PersistentVector"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid214, 12)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ), - ], - meta=nil), - ], - meta=i.Meta(mid193, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/push-tail) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"push-tail")), - i.Fn(args=[kw(u"this"),kw(u"level"),kw(u"parent"),kw(u"tail-node")],name=kw(u"push-tail"), - body=i.Let(names=[kw(u"subidx"),kw(u"ret-array"),kw(u"node-to-insert")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid215, 17)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid215, 26)), - i.Invoke( + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid225, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), + i.Fn(args=[kw(u"self"),kw(u"i")],name=kw(u"-nth_PersistentVector"), + body=i.If( + test=i.If( + test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid215, 43)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid226, 15)), + i.Const(rt.wrap(0)), + i.Lookup(kw(u"i"), meta=i.Meta(mid226, 20)), + ], + meta=i.Meta(mid226, 14)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid227, 15)), + i.Lookup(kw(u"i"), meta=i.Meta(mid227, 17)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid215, 54)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid225, 10)), i.Const(kw(u"cnt")), ], - meta=i.Meta(mid215, 47)), + meta=nil), ], - meta=i.Meta(mid215, 42)), - i.Lookup(kw(u"level"), meta=i.Meta(mid215, 61)), - ], - meta=i.Meta(mid215, 25)), - i.Const(rt.wrap(31)), - ], - meta=i.Meta(mid215, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-clone"), meta=i.Meta(mid216, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"parent"), meta=i.Meta(mid216, 41)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid216, 32)), - ], - meta=i.Meta(mid216, 19)), - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid217, 29)), - i.Lookup(kw(u"level"), meta=i.Meta(mid217, 31)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid217, 28)), - then=i.Lookup(kw(u"tail-node"), meta=i.Meta(mid218, 26)), - els=i.Let(names=[kw(u"child")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid219, 39)), + meta=i.Meta(mid227, 14)), + els=i.Const(nil), + meta=i.Meta(mid226, 9)), + then=i.Let(names=[kw(u"node")], + bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"parent"), meta=i.Meta(mid219, 53)), - i.Const(kw(u"array")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-for"), meta=i.Meta(mid228, 19)), + i.Lookup(kw(u"self"), meta=i.Meta(mid228, 29)), + i.Lookup(kw(u"i"), meta=i.Meta(mid228, 34)), ], - meta=i.Meta(mid219, 44)), - i.Lookup(kw(u"subidx"), meta=i.Meta(mid219, 61)), - ], - meta=i.Meta(mid219, 38)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid220, 33)), - i.Lookup(kw(u"child"), meta=i.Meta(mid220, 35)), - i.Const(nil), - ], - meta=i.Meta(mid220, 32)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid221, 31)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid221, 56)), - i.Const(kw(u"root")), - ], - meta=i.Meta(mid221, 48)), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid221, 40)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid222, 41)), - i.Lookup(kw(u"level"), meta=i.Meta(mid222, 43)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid222, 40)), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid223, 40)), + meta=i.Meta(mid228, 18)), ], - meta=i.Meta(mid221, 30)), - els=i.Invoke( + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid229, 10)), + i.Lookup(kw(u"node"), meta=i.Meta(mid229, 15)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid229, 21)), + i.Lookup(kw(u"i"), meta=i.Meta(mid229, 29)), + i.Const(rt.wrap(31)), + ], + meta=i.Meta(mid229, 20)), + ], + meta=i.Meta(mid229, 9)), + meta=i.Meta(mid228, 7)), + els=i.TailCall( args=[ - i.Lookup(kw(u"push-tail"), meta=i.Meta(mid224, 31)), - i.Lookup(kw(u"this"), meta=i.Meta(mid224, 41)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid225, 42)), - i.Lookup(kw(u"level"), meta=i.Meta(mid225, 44)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid225, 41)), - i.Lookup(kw(u"child"), meta=i.Meta(mid226, 41)), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid227, 41)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid230, 8)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/IndexOutOfRange")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=i.Meta(mid231, 16)), + i.Const(rt.wrap(u"Index out of range, got ")), + i.Lookup(kw(u"i"), meta=i.Meta(mid231, 47)), + i.Const(rt.wrap(u" only have ")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid225, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid231, 15)), + ]), ], - meta=i.Meta(mid224, 30)), - meta=i.Meta(mid220, 28)), - meta=i.Meta(mid219, 26)), - meta=i.Meta(mid217, 24)), + meta=i.Meta(mid230, 7)), + meta=i.Meta(mid226, 5)), + ), ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid228, 6)), - i.Lookup(kw(u"ret-array"), meta=i.Meta(mid228, 11)), - i.Lookup(kw(u"subidx"), meta=i.Meta(mid228, 21)), - i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid228, 28)), - ], - meta=i.Meta(mid228, 5)), - i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid229, 6)), - i.Invoke( + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid232, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), + i.Fn(args=[kw(u"self"),kw(u"i"),kw(u"not-found")],name=kw(u"-nth-not-found_PersistentVector"), + body=i.If( + test=i.If( + test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"parent"), meta=i.Meta(mid229, 21)), - i.Const(kw(u"edit")), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid233, 15)), + i.Const(rt.wrap(0)), + i.Lookup(kw(u"i"), meta=i.Meta(mid233, 20)), ], - meta=i.Meta(mid229, 13)), - i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid229, 29)), - ], - meta=i.Meta(mid229, 5)), - ], - meta=nil), - meta=i.Meta(mid215, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/new-path) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"new-path")), - i.Fn(args=[kw(u"edit"),kw(u"level"),kw(u"node")],name=kw(u"new-path"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid230, 8)), - i.Lookup(kw(u"level"), meta=i.Meta(mid230, 10)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid230, 7)), - then=i.Lookup(kw(u"node"), meta=i.Meta(mid231, 5)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid232, 6)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid232, 13)), - i.Invoke( - args=[ - i.Lookup(kw(u"new-path"), meta=i.Meta(mid233, 14)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid233, 23)), - i.Invoke( + meta=i.Meta(mid233, 14)), + then=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid233, 29)), - i.Lookup(kw(u"level"), meta=i.Meta(mid233, 31)), - i.Const(rt.wrap(5)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid234, 15)), + i.Lookup(kw(u"i"), meta=i.Meta(mid234, 17)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"self"), meta=i.Meta(mid232, 20)), + i.Const(kw(u"cnt")), + ], + meta=nil), ], - meta=i.Meta(mid233, 28)), - i.Lookup(kw(u"node"), meta=i.Meta(mid233, 40)), - ], - meta=i.Meta(mid233, 13)), - ], - meta=i.Meta(mid232, 5)), - meta=i.Meta(mid230, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/EMPTY) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid234, 13)), - i.Const(rt.wrap(0)), - i.Const(rt.wrap(5)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid234, 36)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid234, 48)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid234, 47)), - i.Const(nil), - ], - meta=i.Meta(mid234, 12))]), - i.Invoke(args=[ -# (def pixie.stdlib/vector-from-array) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"vector-from-array")), - i.Fn(args=[kw(u"arr")],name=kw(u"vector-from-array"), - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid235, 4)), - i.Const(rt.wrap(u"Vector for array")), - ], - meta=i.Meta(mid235, 3)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid236, 4)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid236, 13)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid236, 19)), - ], - meta=i.Meta(mid236, 12)), - ], - meta=i.Meta(mid236, 3)), - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid237, 8)), + meta=i.Meta(mid234, 14)), + els=i.Const(nil), + meta=i.Meta(mid233, 9)), + then=i.Let(names=[kw(u"node")], + bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid237, 11)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid237, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-for"), meta=i.Meta(mid235, 19)), + i.Lookup(kw(u"self"), meta=i.Meta(mid235, 29)), + i.Lookup(kw(u"i"), meta=i.Meta(mid235, 34)), ], - meta=i.Meta(mid237, 10)), - i.Const(rt.wrap(32)), - ], - meta=i.Meta(mid237, 7)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid238, 6)), - i.Invoke( + meta=i.Meta(mid235, 18)), + ], + body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid238, 26)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid238, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid236, 10)), + i.Lookup(kw(u"node"), meta=i.Meta(mid236, 15)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid236, 21)), + i.Lookup(kw(u"i"), meta=i.Meta(mid236, 29)), + i.Const(rt.wrap(31)), + ], + meta=i.Meta(mid236, 20)), ], - meta=i.Meta(mid238, 25)), - i.Const(rt.wrap(5)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid238, 39)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid238, 50)), - i.Const(nil), - ], - meta=i.Meta(mid238, 5)), - els=i.TailCall( + meta=i.Meta(mid236, 9)), + meta=i.Meta(mid235, 7)), + els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid237, 7)), + meta=i.Meta(mid233, 5)), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get"), meta=i.Meta(mid238, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), + i.Fn(args=[kw(u"this"),kw(u"val")],name=kw(u"-get_PersistentVector"), + body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid239, 6)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), - i.Lookup(kw(u"arr"), meta=i.Meta(mid239, 14)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid239, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"self"), meta=i.Meta(mid239, 21)), + i.Lookup(kw(u"val"), meta=i.Meta(mid239, 26)), + i.Const(nil), ], meta=i.Meta(mid239, 5)), - meta=i.Meta(mid237, 3)), + ), ], - meta=nil), - )]), - i.Do( - args=[ + meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid240, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid241, 14)), - i.Fn(args=[kw(u"this"),kw(u"f"),kw(u"init")],name=kw(u"fn_533"), - body=i.Let(names=[kw(u"idx"),kw(u"acc")], - bindings=[ - i.Const(rt.wrap(0)), - i.Lookup(kw(u"init"), meta=i.Meta(mid242, 16)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid240, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), + i.Fn(args=[kw(u"this")],name=kw(u"-count_PersistentVector"), + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid240, 12)), + i.Const(kw(u"cnt")), ], - body=i.TailCall( - args=[ - i.Fn(args=[kw(u"idx"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"this"),kw(u"f")], - body=i.Let(names=[kw(u"idx"),kw(u"acc")], - bindings=[ - i.Lookup(kw(u"idx"), meta=i.Meta(mid243, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid242, 12)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid244, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid244, 21)), - ], - meta=i.Meta(mid244, 11)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), - i.Lookup(kw(u"acc"), meta=i.Meta(mid245, 10)), - ], - meta=i.Meta(mid245, 9)), - els=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid246, 14)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid246, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid246, 21)), - i.Lookup(kw(u"this"), meta=i.Meta(mid246, 27)), - ], - meta=i.Meta(mid246, 20)), - ], - meta=i.Meta(mid246, 13)), + meta=nil), + ), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-pop"), meta=i.Meta(mid241, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), + i.Fn(args=[kw(u"this")],name=kw(u"-pop_PersistentVector"), + body=i.Do( + args=[ + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"!="), meta=i.Meta(mid242, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid242, 13)), + then=i.Const(nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=nil), + i.Const(rt.wrap(u"Assert failed: ")), + i.Const(rt.wrap(u"Can't pop an empty vector")), + ], + meta=nil), + ]), + ], + meta=nil), + meta=i.Meta(mid242, 5)), + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"=="), meta=i.Meta(mid243, 10)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid243, 9)), + then=i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY"), meta=i.Meta(mid244, 7)), + els=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid245, 12)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid245, 15)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid245, 22)), + i.Lookup(kw(u"this"), meta=i.Meta(mid245, 30)), + ], + meta=i.Meta(mid245, 21)), + ], + meta=i.Meta(mid245, 14)), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid245, 11)), + then=i.Let(names=[kw(u"size"),kw(u"new-tail")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid246, 21)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid246, 26)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"tail")), + ], + meta=nil), + ], + meta=i.Meta(mid246, 25)), + ], + meta=i.Meta(mid246, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-resize"), meta=i.Meta(mid247, 25)), + i.Lookup(kw(u"size"), meta=i.Meta(mid247, 38)), + ], + meta=i.Meta(mid247, 24)), + ], + body=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid248, 12)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid248, 32)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid248, 31)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"root")), + ], + meta=nil), + i.Lookup(kw(u"new-tail"), meta=i.Meta(mid249, 31)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"meta")), + ], + meta=nil), + ], + meta=i.Meta(mid248, 11)), + meta=i.Meta(mid246, 9)), + els=i.Let(names=[kw(u"new-tail"),kw(u"new-root")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-for"), meta=i.Meta(mid250, 25)), + i.Lookup(kw(u"this"), meta=i.Meta(mid250, 35)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid250, 41)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + i.Const(rt.wrap(2)), + ], + meta=i.Meta(mid250, 40)), + ], + meta=i.Meta(mid250, 24)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"pop-tail"), meta=i.Meta(mid251, 25)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"root")), + ], + meta=nil), + ], + meta=i.Meta(mid251, 24)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"nil?"), meta=i.Meta(mid252, 14)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid252, 19)), + ], + meta=i.Meta(mid252, 13)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersisentVector"), meta=i.Meta(mid253, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid253, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid253, 32)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid254, 32)), + i.Lookup(kw(u"new-tail"), meta=i.Meta(mid255, 32)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"meta")), + ], + meta=nil), + ], + meta=i.Meta(mid253, 13)), + els=i.If( + test=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid256, 19)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid256, 18)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"nil?"), meta=i.Meta(mid257, 19)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid257, 25)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid257, 39)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid257, 30)), + i.Const(rt.wrap(1)), + ], + meta=i.Meta(mid257, 24)), + ], + meta=i.Meta(mid257, 18)), + els=i.Const(nil), + meta=i.Meta(mid256, 13)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid258, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid258, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid258, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid259, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid259, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid260, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid260, 48)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid260, 39)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid260, 33)), + i.Lookup(kw(u"new-tail"), meta=i.Meta(mid261, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"meta")), + ], + meta=nil), + ], + meta=i.Meta(mid258, 13)), + els=i.If( + test=i.Const(kw(u"else")), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid262, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid262, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"cnt")), + ], + meta=nil), + ], + meta=i.Meta(mid262, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"shift")), + ], + meta=nil), + i.Lookup(kw(u"new-root"), meta=i.Meta(mid263, 33)), + i.Lookup(kw(u"new-tail"), meta=i.Meta(mid264, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), + i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), + i.Const(kw(u"meta")), + ], + meta=nil), + ], + meta=i.Meta(mid262, 13)), + els=i.Const(nil), + meta=nil), + meta=nil), + meta=i.Meta(mid265, 11)), + meta=i.Meta(mid250, 9)), + meta=i.Meta(mid245, 7)), + meta=i.Meta(mid243, 5)), + ], + meta=nil), + ), + ], + meta=nil), + ], + meta=i.Meta(mid203, 1)), + i.Invoke(args=[ +# (def pixie.stdlib/push-tail) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"push-tail")), + i.Fn(args=[kw(u"this"),kw(u"level"),kw(u"parent"),kw(u"tail-node")],name=kw(u"push-tail"), + body=i.Let(names=[kw(u"subidx"),kw(u"ret-array"),kw(u"node-to-insert")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid266, 17)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid266, 26)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid266, 43)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid266, 54)), + i.Const(kw(u"cnt")), + ], + meta=i.Meta(mid266, 47)), + ], + meta=i.Meta(mid266, 42)), + i.Lookup(kw(u"level"), meta=i.Meta(mid266, 61)), + ], + meta=i.Meta(mid266, 25)), + i.Const(rt.wrap(31)), + ], + meta=i.Meta(mid266, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-clone"), meta=i.Meta(mid267, 20)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"parent"), meta=i.Meta(mid267, 41)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid267, 32)), + ], + meta=i.Meta(mid267, 19)), + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid268, 29)), + i.Lookup(kw(u"level"), meta=i.Meta(mid268, 31)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid268, 28)), + then=i.Lookup(kw(u"tail-node"), meta=i.Meta(mid269, 26)), + els=i.Let(names=[kw(u"child")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid270, 39)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"parent"), meta=i.Meta(mid270, 53)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid270, 44)), + i.Lookup(kw(u"subidx"), meta=i.Meta(mid270, 61)), + ], + meta=i.Meta(mid270, 38)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid271, 33)), + i.Lookup(kw(u"child"), meta=i.Meta(mid271, 35)), + i.Const(nil), + ], + meta=i.Meta(mid271, 32)), + then=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid272, 31)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid272, 56)), + i.Const(kw(u"root")), + ], + meta=i.Meta(mid272, 48)), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid272, 40)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid273, 41)), + i.Lookup(kw(u"level"), meta=i.Meta(mid273, 43)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid273, 40)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid274, 40)), + ], + meta=i.Meta(mid272, 30)), + els=i.Invoke( + args=[ + i.Lookup(kw(u"push-tail"), meta=i.Meta(mid275, 31)), + i.Lookup(kw(u"this"), meta=i.Meta(mid275, 41)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid276, 42)), + i.Lookup(kw(u"level"), meta=i.Meta(mid276, 44)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid276, 41)), + i.Lookup(kw(u"child"), meta=i.Meta(mid277, 41)), + i.Lookup(kw(u"tail-node"), meta=i.Meta(mid278, 41)), + ], + meta=i.Meta(mid275, 30)), + meta=i.Meta(mid271, 28)), + meta=i.Meta(mid270, 26)), + meta=i.Meta(mid268, 24)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid279, 6)), + i.Lookup(kw(u"ret-array"), meta=i.Meta(mid279, 11)), + i.Lookup(kw(u"subidx"), meta=i.Meta(mid279, 21)), + i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid279, 28)), + ], + meta=i.Meta(mid279, 5)), + i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid280, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"parent"), meta=i.Meta(mid280, 21)), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid280, 13)), + i.Lookup(kw(u"ret-array"), meta=i.Meta(mid280, 29)), + ], + meta=i.Meta(mid280, 5)), + ], + meta=nil), + meta=i.Meta(mid266, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/pop-tail) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"pop-tail")), + i.Fn(args=[kw(u"this"),kw(u"level"),kw(u"node")],name=kw(u"pop-tail"), + body=i.Let(names=[kw(u"sub-idx")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid281, 18)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid281, 27)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid281, 44)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Const(kw(u"cnt")), + ], + meta=i.Meta(mid281, 48)), + ], + meta=i.Meta(mid281, 43)), + i.Lookup(kw(u"level"), meta=i.Meta(mid281, 57)), + ], + meta=i.Meta(mid281, 26)), + i.Const(rt.wrap(31)), + ], + meta=i.Meta(mid281, 17)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid282, 8)), + i.Lookup(kw(u"level"), meta=i.Meta(mid282, 10)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid282, 7)), + then=i.Let(names=[kw(u"new-child")], + bindings=[ + i.Invoke( + args=[ + i.Lookup(kw(u"pop-tail"), meta=i.Meta(mid283, 24)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid283, 34)), + i.Lookup(kw(u"level"), meta=i.Meta(mid283, 36)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid283, 33)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid284, 34)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"node"), meta=i.Meta(mid284, 48)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid284, 39)), + i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid284, 54)), + ], + meta=i.Meta(mid284, 33)), + ], + meta=i.Meta(mid283, 23)), + ], + body=i.If( + test=i.Let(names=[kw(u"r#__gensym_320")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"nil?"), meta=i.Meta(mid285, 18)), + i.Lookup(kw(u"new-child"), meta=i.Meta(mid285, 23)), + ], + meta=i.Meta(mid285, 17)), + ], + body=i.If( + test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid286, 18)), + i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid286, 20)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid286, 17)), + meta=nil), + meta=i.Meta(mid285, 13)), + then=i.Const(nil), + els=i.Let(names=[kw(u"root"),kw(u"ret")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid287, 30)), + i.Const(kw(u"root")), + ], + meta=i.Meta(mid287, 22)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid288, 22)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"root"), meta=i.Meta(mid288, 37)), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid288, 29)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"node"), meta=i.Meta(mid289, 38)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid289, 29)), + ], + meta=i.Meta(mid288, 21)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid290, 14)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"ret"), meta=i.Meta(mid290, 28)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid290, 19)), + i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid290, 33)), + i.Lookup(kw(u"new-child"), meta=i.Meta(mid290, 41)), + ], + meta=i.Meta(mid290, 13)), + i.Lookup(kw(u"ret"), meta=i.Meta(mid291, 13)), + ], + meta=nil), + meta=i.Meta(mid287, 11)), + meta=i.Meta(mid285, 9)), + meta=i.Meta(mid283, 7)), + els=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid292, 8)), + i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid292, 10)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid292, 7)), + then=i.Const(nil), + els=i.If( + test=i.Const(kw(u"else")), + then=i.Let(names=[kw(u"root"),kw(u"ret")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"this"), meta=i.Meta(mid293, 26)), + i.Const(kw(u"root")), + ], + meta=i.Meta(mid293, 18)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid294, 18)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"root"), meta=i.Meta(mid294, 33)), + i.Const(kw(u"edit")), + ], + meta=i.Meta(mid294, 25)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aclone"), meta=i.Meta(mid295, 26)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"node"), meta=i.Meta(mid295, 42)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid295, 33)), + ], + meta=i.Meta(mid295, 25)), + ], + meta=i.Meta(mid294, 17)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid296, 10)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"ret"), meta=i.Meta(mid296, 24)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid296, 15)), + i.Const(nil), + ], + meta=i.Meta(mid296, 9)), + i.Lookup(kw(u"ret"), meta=i.Meta(mid297, 9)), + ], + meta=nil), + meta=i.Meta(mid293, 7)), + els=i.Const(nil), + meta=nil), + meta=nil), + meta=i.Meta(mid298, 5)), + meta=i.Meta(mid281, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/new-path) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"new-path")), + i.Fn(args=[kw(u"edit"),kw(u"level"),kw(u"node")],name=kw(u"new-path"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid299, 8)), + i.Lookup(kw(u"level"), meta=i.Meta(mid299, 10)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid299, 7)), + then=i.Lookup(kw(u"node"), meta=i.Meta(mid300, 5)), + els=i.Let(names=[kw(u"nnode")], + bindings=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid301, 18)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid301, 27)), + ], + meta=i.Meta(mid301, 17)), + ], + body=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid302, 8)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"nnode"), meta=i.Meta(mid302, 22)), + i.Const(kw(u"array")), + ], + meta=i.Meta(mid302, 13)), + i.Const(rt.wrap(0)), + i.Invoke( + args=[ + i.Lookup(kw(u"new-path"), meta=i.Meta(mid302, 32)), + i.Lookup(kw(u"edit"), meta=i.Meta(mid302, 41)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid302, 47)), + i.Lookup(kw(u"level"), meta=i.Meta(mid302, 49)), + i.Const(rt.wrap(5)), + ], + meta=i.Meta(mid302, 46)), + i.Lookup(kw(u"node"), meta=i.Meta(mid302, 58)), + ], + meta=i.Meta(mid302, 31)), + ], + meta=i.Meta(mid302, 7)), + i.Lookup(kw(u"nnode"), meta=i.Meta(mid303, 7)), + ], + meta=nil), + meta=i.Meta(mid301, 5)), + meta=i.Meta(mid299, 3)), + )]), + i.Invoke(args=[ +# (def pixie.stdlib/EMPTY) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY")), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid304, 13)), + i.Const(rt.wrap(0)), + i.Const(rt.wrap(5)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid304, 36)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid304, 48)), + i.Const(rt.wrap(0)), + ], + meta=i.Meta(mid304, 47)), + i.Const(nil), + ], + meta=i.Meta(mid304, 12))]), + i.Invoke(args=[ +# (def pixie.stdlib/vector-from-array) + i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), + i.Const(code.intern_var(u"pixie.stdlib",u"vector-from-array")), + i.Fn(args=[kw(u"arr")],name=kw(u"vector-from-array"), + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid305, 8)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid305, 11)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid305, 17)), + ], + meta=i.Meta(mid305, 10)), + i.Const(rt.wrap(32)), + ], + meta=i.Meta(mid305, 7)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid306, 6)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid306, 26)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid306, 32)), + ], + meta=i.Meta(mid306, 25)), + i.Const(rt.wrap(5)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid306, 39)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid306, 50)), + i.Const(nil), + ], + meta=i.Meta(mid306, 5)), + els=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid307, 6)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), + i.Lookup(kw(u"arr"), meta=i.Meta(mid307, 14)), + ], + meta=i.Meta(mid307, 5)), + meta=i.Meta(mid305, 3)), + )]), + i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid308, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid309, 14)), + i.Fn(args=[kw(u"this"),kw(u"f"),kw(u"init")],name=kw(u"fn_564"), + body=i.Let(names=[kw(u"idx"),kw(u"acc")], + bindings=[ + i.Const(rt.wrap(0)), + i.Lookup(kw(u"init"), meta=i.Meta(mid310, 16)), + ], + body=i.TailCall( + args=[ + i.Fn(args=[kw(u"idx"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"this"),kw(u"f")], + body=i.Let(names=[kw(u"idx"),kw(u"acc")], + bindings=[ + i.Lookup(kw(u"idx"), meta=i.Meta(mid311, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid310, 12)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid312, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid312, 21)), + ], + meta=i.Meta(mid312, 11)), + then=i.TailCall( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), + i.Lookup(kw(u"acc"), meta=i.Meta(mid313, 10)), + ], + meta=i.Meta(mid313, 9)), + els=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid314, 14)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid314, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid314, 21)), + i.Lookup(kw(u"this"), meta=i.Meta(mid314, 27)), + ], + meta=i.Meta(mid314, 20)), + ], + meta=i.Meta(mid314, 13)), then=i.TailCall( args=[ i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid247, 19)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid247, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid315, 19)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid315, 23)), ], - meta=i.Meta(mid247, 18)), + meta=i.Meta(mid315, 18)), i.Invoke( args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid248, 19)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid248, 21)), + i.Lookup(kw(u"f"), meta=i.Meta(mid316, 19)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid316, 21)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid248, 26)), - i.Lookup(kw(u"this"), meta=i.Meta(mid248, 31)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid248, 36)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid316, 26)), + i.Lookup(kw(u"this"), meta=i.Meta(mid316, 31)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid316, 36)), ], - meta=i.Meta(mid248, 25)), + meta=i.Meta(mid316, 25)), ], - meta=i.Meta(mid248, 18)), + meta=i.Meta(mid316, 18)), ], meta=nil), - els=i.Lookup(kw(u"acc"), meta=i.Meta(mid249, 11)), - meta=i.Meta(mid246, 9)), - meta=i.Meta(mid244, 7)), + els=i.Lookup(kw(u"acc"), meta=i.Meta(mid317, 11)), + meta=i.Meta(mid314, 9)), + meta=i.Meta(mid312, 7)), meta=nil), ), - i.Lookup(kw(u"idx"), meta=i.Meta(mid243, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid242, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid311, 12)), + i.Lookup(kw(u"acc"), meta=i.Meta(mid310, 12)), ], meta=nil), - meta=i.Meta(mid243, 5)), + meta=i.Meta(mid311, 5)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid250, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid241, 14)), - i.Fn(args=[kw(u"arr")],name=kw(u"fn_537"), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid318, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid309, 14)), + i.Fn(args=[kw(u"arr")],name=kw(u"fn_568"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=nil), - i.Lookup(kw(u"arr"), meta=i.Meta(mid251, 21)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid319, 21)), i.Const(kw(u"count")), ], - meta=i.Meta(mid251, 12)), + meta=i.Meta(mid319, 12)), ), ], meta=nil), i.Invoke( args=[ i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid252, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid241, 14)), - i.Fn(args=[kw(u"arr"),kw(u"itm")],name=kw(u"fn_529"), + i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid320, 4)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid309, 14)), + i.Fn(args=[kw(u"arr"),kw(u"itm")],name=kw(u"fn_560"), body=i.TailCall( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid253, 6)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid321, 6)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"vector-from-array"), meta=i.Meta(mid253, 12)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid253, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"vector-from-array"), meta=i.Meta(mid321, 12)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid321, 30)), ], - meta=i.Meta(mid253, 11)), - i.Lookup(kw(u"itm"), meta=i.Meta(mid253, 35)), + meta=i.Meta(mid321, 11)), + i.Lookup(kw(u"itm"), meta=i.Meta(mid321, 35)), ], - meta=i.Meta(mid253, 5)), + meta=i.Meta(mid321, 5)), ), ], meta=nil), ], - meta=i.Meta(mid241, 1)), + meta=i.Meta(mid309, 1)), i.Invoke(args=[ # (def pixie.stdlib/array-copy) i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), @@ -4193,65 +5144,65 @@ i.Fn(args=[kw(u"idx")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"size"),kw(u"from-idx"),kw(u"to"),kw(u"to-idx"),kw(u"from")], body=i.Let(names=[kw(u"idx")], bindings=[ - i.Lookup(kw(u"idx"), meta=i.Meta(mid254, 10)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid322, 10)), ], body=i.If( test=i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid255, 12)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid255, 14)), - i.Lookup(kw(u"size"), meta=i.Meta(mid255, 18)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid323, 12)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid323, 14)), + i.Lookup(kw(u"size"), meta=i.Meta(mid323, 18)), ], - meta=i.Meta(mid255, 11)), + meta=i.Meta(mid323, 11)), then=i.Do( args=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid256, 12)), - i.Lookup(kw(u"to"), meta=i.Meta(mid256, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid324, 12)), + i.Lookup(kw(u"to"), meta=i.Meta(mid324, 17)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid256, 21)), - i.Lookup(kw(u"to-idx"), meta=i.Meta(mid256, 23)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid256, 30)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid324, 21)), + i.Lookup(kw(u"to-idx"), meta=i.Meta(mid324, 23)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid324, 30)), ], - meta=i.Meta(mid256, 20)), + meta=i.Meta(mid324, 20)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid256, 36)), - i.Lookup(kw(u"from"), meta=i.Meta(mid256, 41)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid324, 36)), + i.Lookup(kw(u"from"), meta=i.Meta(mid324, 41)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid256, 47)), - i.Lookup(kw(u"from-idx"), meta=i.Meta(mid256, 49)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid256, 58)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid324, 47)), + i.Lookup(kw(u"from-idx"), meta=i.Meta(mid324, 49)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid324, 58)), ], - meta=i.Meta(mid256, 46)), + meta=i.Meta(mid324, 46)), ], - meta=i.Meta(mid256, 35)), + meta=i.Meta(mid324, 35)), ], - meta=i.Meta(mid256, 11)), + meta=i.Meta(mid324, 11)), i.TailCall( args=[ i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid257, 19)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid257, 23)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid325, 19)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid325, 23)), ], - meta=i.Meta(mid257, 18)), + meta=i.Meta(mid325, 18)), ], meta=nil), ], - meta=i.Meta(mid256, 7)), + meta=i.Meta(mid324, 7)), els=i.Const(nil), - meta=i.Meta(mid255, 5)), + meta=i.Meta(mid323, 5)), meta=nil), ), - i.Lookup(kw(u"idx"), meta=i.Meta(mid254, 10)), + i.Lookup(kw(u"idx"), meta=i.Meta(mid322, 10)), ], meta=nil), - meta=i.Meta(mid254, 3)), + meta=i.Meta(mid322, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/array-append) @@ -4262,55 +5213,55 @@ bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid258, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid326, 20)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid258, 32)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid326, 32)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid258, 37)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid258, 43)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid326, 37)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid326, 43)), ], - meta=i.Meta(mid258, 36)), + meta=i.Meta(mid326, 36)), ], - meta=i.Meta(mid258, 31)), + meta=i.Meta(mid326, 31)), ], - meta=i.Meta(mid258, 19)), + meta=i.Meta(mid326, 19)), ], body=i.Do( args=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid259, 6)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid259, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid327, 6)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid327, 17)), i.Const(rt.wrap(0)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid259, 23)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid327, 23)), i.Const(rt.wrap(0)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid259, 36)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid259, 42)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid327, 36)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid327, 42)), ], - meta=i.Meta(mid259, 35)), + meta=i.Meta(mid327, 35)), ], - meta=i.Meta(mid259, 5)), + meta=i.Meta(mid327, 5)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid260, 6)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid260, 11)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid328, 6)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid328, 11)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid260, 22)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid260, 28)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid328, 22)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid328, 28)), ], - meta=i.Meta(mid260, 21)), - i.Lookup(kw(u"val"), meta=i.Meta(mid260, 33)), + meta=i.Meta(mid328, 21)), + i.Lookup(kw(u"val"), meta=i.Meta(mid328, 33)), ], - meta=i.Meta(mid260, 5)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid261, 5)), + meta=i.Meta(mid328, 5)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid329, 5)), ], meta=nil), - meta=i.Meta(mid258, 3)), + meta=i.Meta(mid326, 3)), )]), i.Invoke(args=[ # (def pixie.stdlib/array-clone) @@ -4321,51 +5272,134 @@ bindings=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid262, 20)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid330, 20)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid262, 32)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid262, 38)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid330, 32)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid330, 38)), ], - meta=i.Meta(mid262, 31)), + meta=i.Meta(mid330, 31)), ], - meta=i.Meta(mid262, 19)), + meta=i.Meta(mid330, 19)), ], body=i.Do( args=[ i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid263, 6)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid263, 17)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid331, 6)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid331, 17)), i.Const(rt.wrap(0)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid263, 23)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid331, 23)), i.Const(rt.wrap(0)), i.Invoke( args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid263, 36)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid263, 42)), + i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid331, 36)), + i.Lookup(kw(u"arr"), meta=i.Meta(mid331, 42)), ], - meta=i.Meta(mid263, 35)), + meta=i.Meta(mid331, 35)), ], - meta=i.Meta(mid263, 5)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid264, 5)), + meta=i.Meta(mid331, 5)), + i.Lookup(kw(u"new-array"), meta=i.Meta(mid332, 5)), ], meta=nil), - meta=i.Meta(mid262, 3)), + meta=i.Meta(mid330, 3)), )]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid265, 2)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid265, 11)), - i.Const(rt.wrap(40)), - ], - meta=i.Meta(mid265, 10)), + i.Let(names=[kw(u"MAX"),kw(u"v")], + bindings=[ + i.Const(rt.wrap(1024)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid333, 10)), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid333, 19)), + i.Lookup(kw(u"MAX"), meta=i.Meta(mid333, 25)), + ], + meta=i.Meta(mid333, 18)), + ], + meta=i.Meta(mid333, 9)), ], - meta=i.Meta(mid265, 1)), + body=i.Let(names=[kw(u"max#__gensym_319")], + bindings=[ + i.Lookup(kw(u"MAX"), meta=i.Meta(mid334, 15)), + ], + body=i.Let(names=[kw(u"x")], + bindings=[ + i.Const(rt.wrap(0)), + ], + body=i.Invoke( + args=[ + i.Fn(args=[kw(u"x")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"v"),kw(u"max#__gensym_319")], + body=i.Let(names=[kw(u"x")], + bindings=[ + i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), + ], + body=i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=nil), + i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), + i.Lookup(kw(u"max#__gensym_319"), meta=nil), + ], + meta=nil), + then=i.Const(nil), + els=i.Do( + args=[ + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid335, 6)), + i.Lookup(kw(u"x"), meta=i.Meta(mid335, 14)), + ], + meta=i.Meta(mid335, 5)), + i.If( + test=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid336, 14)), + i.Lookup(kw(u"x"), meta=i.Meta(mid336, 16)), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"nth"), meta=i.Meta(mid336, 19)), + i.Lookup(kw(u"v"), meta=i.Meta(mid336, 23)), + i.Lookup(kw(u"x"), meta=i.Meta(mid336, 25)), + ], + meta=i.Meta(mid336, 18)), + ], + meta=i.Meta(mid336, 13)), + then=i.Const(nil), + els=i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), + i.Invoke(args=[ + i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), + i.Const(rt.wrap(u"Assert failed")), + ]), + ], + meta=nil), + meta=i.Meta(mid336, 5)), + i.TailCall( + args=[ + i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), + i.Invoke( + args=[ + i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=nil), + i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), + ], + meta=nil), + ], + meta=nil), + ], + meta=nil), + meta=nil), + meta=nil), + ), + i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), + ], + meta=nil), + meta=nil), + meta=i.Meta(mid334, 3)), + meta=i.Meta(mid337, 1)), i.Const(nil), ], -meta=i.Meta(mid266, 1)) \ No newline at end of file +meta=i.Meta(mid338, 1)) \ No newline at end of file diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index dd3205bf..65c728ce 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -94,12 +94,18 @@ (extend -get-field Object -internal-get-field) -(extend -str Object (fn [x sb] - (sb (-internal-to-str x)))) -(extend -repr Object (fn [x sb] - (sb (-internal-to-repr x)))) +(extend-type Object + (-str [x sb] + (sb (-internal-to-str x))) + + (-repr [x sb] + (sb (-internal-to-repr x))) + + (-eq [this other] + false)) + (extend-type String IObject (-str [this sb] @@ -142,6 +148,22 @@ ([x y & more] (-apply > (> x y) more))) + +(defn <= + ([x] true) + ([x y] (-lte x y)) + ([x y & rest] (if (-lte x y) + (apply <= y rest) + false))) + +(defn >= + ([x] true) + ([x y] (-gte x y)) + ([x y & rest] (if (-gte x y) + (apply >= y rest) + false))) + + (defn = {:doc "Returns true if all the arguments are equivalent. Otherwise, returns false. Uses -eq to perform equality checks." @@ -163,6 +185,15 @@ (-apply conj (conj x y) more))) +(defn nth + {:doc "Returns the element at the idx. If the index is not found it will return an error. + However, if you specify a not-found parameter, it will substitute that instead" + :signatures [[coll idx] [coll idx not-found]] + :added "0.1"} + ([coll idx] (-nth coll idx)) + ([coll idx not-found] (-nth-not-found coll idx not-found))) + + (defn count ([coll] (-count coll))) @@ -331,13 +362,13 @@ ;; Range +(in-ns :pixie.stdlib.range) + (deftype Range [start stop step] IReduce (-reduce [self f init] (loop [i start acc init] - (println i) - (println acc) (if (or (and (> step 0) (< i stop)) (and (< step 0) (> i stop)) (and (= step 0))) @@ -378,10 +409,13 @@ (-str (seq this) sbf)) (-repr [this sbf] (-repr (seq this) sbf)) - (-eq [this sb])) + (-eq [this sb] + nil)) (def MAX-NUMBER 0xFFFFFFFF) ;; 32 bits ought to be enough for anyone ;-) +(in-ns :pixie.stdlib) + (defn range {:doc "Returns a range of numbers." :examples [["(seq (range 3))" nil (0 1 2)] @@ -390,10 +424,10 @@ ["(seq (range 5 -1 -1))" nil (5 4 3 2 1 0)]] :signatures [[] [stop] [start stop] [start stop step]] :added "0.1"} - ([] (->Range 0 MAX-NUMBER 1)) - ([stop] (->Range 0 stop 1)) - ([start stop] (->Range start stop 1)) - ([start stop step] (->Range start stop step))) + ([] (pixie.stdlib.range/->Range 0 MAX-NUMBER 1)) + ([stop] (pixie.stdlib.range/->Range 0 stop 1)) + ([start stop] (pixie.stdlib.range/->Range start stop 1)) + ([start stop step] (pixie.stdlib.range/->Range start stop step))) ;; End Range @@ -406,7 +440,7 @@ (defn new-node ([edit] - (new-node edit (array 32))) + (new-node edit (make-array 32))) ([edit array] (->Node edit array))) @@ -420,18 +454,19 @@ 0 (bit-shift-left (bit-shift-right (dec cnt) 5) 5)))) -(defn array-for [this i cnt root shift tail] - (if (and (<= 0 i) (< i cnt)) - (if (>= i (tailoff this)) - tail - (.-array ((fn look-deeper [node level] - (if (> level 0) - (look-deeper (aget (:array node) - (bit-and (bit-shift-right i level) 0x01f)) - (- level 5)) - (:array node))) - root - shift))))) +(defn array-for [this i] + (if (and (<= 0 i) (< i (.-cnt this))) + (if (>= i (tailoff this)) + (.-tail this) + (loop [node (.-root this) + level (.-shift this)] + (if (> level 0) + (recur (aget (.-array node) + (bit-and (bit-shift-right i level) 0x01f)) + (- level 5)) + (.-array node)))) + (throw [:pixie.stdlib/IndexOutOfRangeException + "Index out of range"]))) (deftype PersistentVector [cnt shift root tail meta] IMessageObject @@ -449,9 +484,10 @@ (let [tail-node (->Node (.-edit root) tail)] (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift)) - (let [new-root (new-node (.-edit root))] - (aset new-root 0 root) - (aset new-root 1 (new-path (.-edit root) shift tail-node)) + (let [new-root (new-node (.-edit root)) + new-root-arr (.-array new-root)] + (aset new-root-arr 0 root) + (aset new-root-arr 1 (new-path (.-edit root) shift tail-node)) (->PersistentVector (inc cnt) (+ shift 5) new-root @@ -463,9 +499,69 @@ new-root (array val) meta)))))) + IIndexed + (-nth [self i] + (if (and (<= 0 i) + (< i cnt)) + (let [node (array-for self i)] + (aget node (bit-and i 0x01F))) + (throw [:pixie.stdlib/IndexOutOfRange + (str "Index out of range, got " i " only have " cnt)]))) + + (-nth-not-found [self i not-found] + (if (and (<= 0 i) + (< i cnt)) + (let [node (array-for self i)] + (aget node (bit-and i 0x01F))) + not-found)) + + + + ILookup + (-get [this val] + (-nth-not-found self val nil)) + ICounted - (-count [this] cnt)) + (-count [this] cnt) + + IPop + (-pop [this] + (assert (!= cnt) "Can't pop an empty vector") + + (if (== cnt 1) + EMPTY + (if (> (- cnt (tailoff this)) 1) + (let [size (dec (count tail)) + new-tail (array-resize size)] + (->PersistentVector (dec cnt) + shift + root + new-tail + meta)) + (let [new-tail (array-for this (- cnt 2)) + new-root (pop-tail shift root)] + (cond + (nil? new-root) + (->PersisentVector (dec cnt) + shift + EMPTY-NODE + new-tail + meta) + (and (> shift 5) + (nil? (aget (.-array new-root) 1))) + (->PersistentVector (dec cnt) + (- shift 5) + (aget (.-array new-root) 0) + new-tail + meta) + + :else + (->PersistentVector (dec cnt) + shift + new-root + new-tail + meta))))))) (defn push-tail [this level parent tail-node] @@ -483,20 +579,44 @@ child tail-node))))] (aset ret-array subidx node-to-insert) - (->Node (.-edit parent) node-to-insert))) + (->Node (.-edit parent) ret-array))) + +(defn pop-tail [this level node] + (let [sub-idx (bit-and (bit-shift-right (dec (.-cnt)) level) 0x01F)] + (cond + (> level 5) + (let [new-child (pop-tail (- level 5) + (aget (.-array node) sub-idx))] + (if (or (nil? new-child) + (= sub-idx 0)) + nil + (let [root (.-root this) + ret (->Node (.-edit root) + (.-array node))] + (aset (.-array ret) sub-idx new-child) + ret))) + + (= sub-idx 0) + nil + + :else + (let [root (.-root this) + ret (->Node (.-edit root) + (aclone (.-array node)))] + (aset (.-array ret) nil) + ret)))) (defn new-path [edit level node] (if (= level 0) node - (->Node edit - (new-path edit (- level 5) node)))) + (let [nnode (new-node edit)] + (aset (.-array nnode) 0 (new-path edit (- level 5) node)) + nnode))) (def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil)) (defn vector-from-array [arr] - (println "Vector for array") - (println (count arr)) (if (< (count arr) 32) (->PersistentVector (count arr) 5 EMPTY-NODE arr nil) (into [] arr))) @@ -542,7 +662,19 @@ ;;; -(into [] (range 40)) +(let [MAX 1024 + v (into [] (range MAX))] + (dotimes [x MAX] + (println x) + (assert (= x (nth v x))))) + +#_(let [arr1 (make-array 32) + arr2 (make-array 32)] + (dotimes [x 3000] + (array-copy arr1 0 arr2 0 (count arr1)))) + +#_(dotimes [x 10000] + (dotimes [y 5])) (comment (println 42) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 96a4d64d..1395c146 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -7,9 +7,9 @@ (resolve 'defprotocol) (fn [nm & sigs] - `(do (def ~nm (protocol ~(str nm))) + `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) ~@(map (fn [[x]] - `(def ~x (polymorphic-fn ~(str x) ~nm))) + `(def ~x (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm))) sigs))) (resolve 'deftype) @@ -52,7 +52,9 @@ body) proto-bodies (second bodies) all-fields fields - type-decl `(def ~nm (create-type ~(keyword (name nm)) ~all-fields)) + type-nm (str (:ns *env*) "." (name nm)) + type-decl `(def ~nm (create-type ~(keyword type-nm) + ~all-fields)) inst (gensym) ctor `(defn ~ctor-name ~field-syms (new ~nm @@ -61,7 +63,9 @@ (map (fn [body] (cond (symbol? body) `(satisfy ~body ~nm) - (seq? body) `(extend ~(first body) ~nm ~(mk-body body)) + (seq? body) `(extend ~(first body) + ~(symbol (str (:ns *env*) "/" nm)) + ~(mk-body body)) :else (assert false "Unknown body element in deftype, expected symbol or seq")))) conj proto-bodies)] @@ -250,6 +254,13 @@ :else :unknown) :form val}) +(defmethod analyze-seq 'in-ns + [[_ nsp]] + (set! (var *env*) (assoc *env* :ns (symbol (name nsp)))) + (in-ns nsp) + (in-ns :pixie.compiler) + (analyze-form nil)) + (defmethod analyze-seq 'local-macro [[_ [nm replace] & body :as form]] (binding [*env* (assoc-in *env* [:locals nm] {:op :local-macro @@ -281,18 +292,22 @@ (defmethod analyze-seq :default [[sym & args :as form]] - (let [resolved (and (symbol? sym) - (resolve-in (the-ns (:ns *env*)) sym))] + (let [resolved (try (and (symbol? sym) + (resolve-in (the-ns (:ns *env*)) sym)) + (catch :pixie.stdlib/AssertionException ex + nil))] + (println sym resolved [ (if resolved + (namespace resolved))] + (:ns *env*) + (contains? macro-overrides resolved)) (cond (and (symbol? sym) (string/starts-with? (name sym) ".-")) (let [sym-kw (keyword (string/substring (name sym) 2))] - (analyze-form (keep-meta `(-get-field ~@args ~sym-kw) + (analyze-form (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw) form))) - - (and resolved - (contains? macro-overrides resolved)) + (contains? macro-overrides resolved) (analyze-form (keep-meta (apply (macro-overrides resolved) args) form)) @@ -355,8 +370,20 @@ :env *env*}) (defn maybe-var [x] - (let [resolved (resolve-in (the-ns (:ns *env*)) x)] + (let [namesp (the-ns (:ns *env*)) + resolved (try + (resolve-in namesp x) + (catch :pixie.stdlib/AssertionException ex + nil))] + (println x (namespace x) (name x)) (cond + (namespace x) + {:op :var + :env *env* + :ns (symbol (namespace x)) + :name (symbol (name x)) + :form x} + (get-in @(:vars *env*) [(:ns *env*) x]) {:op :var :env *env* diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index fcc554d3..ff08e989 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -91,7 +91,7 @@ def slice_from_start(from_list, count, extra=r_uint(0)): class BaseCode(object.Object): - _immutable_fields_ = ["_meta"] + _immutable_fields_ = ["_meta", "_name"] def __init__(self): from pixie.vm2.string import String assert isinstance(self, BaseCode) @@ -147,7 +147,7 @@ def join_last(words, sep): class MultiArityFn(BaseCode): _type = object.Type(u"pixie.stdlib.MultiArityFn") - _immutable_fields_ = ["_arities[*]", "_required_arity", "_rest_fn"] + _immutable_fields_ = ["_arities[*]", "_required_arity", "_rest_fn", "_name"] def type(self): return MultiArityFn._type @@ -164,15 +164,23 @@ def with_meta(self, meta): return MultiArityFn(self._name, self._arities, self._required_arity, self._rest_fn, meta) @elidable_promote() - def get_fn(self, arity): + def _get_fn(self, arity): f = self._arities.get(arity, None) if f is not None: return f if self._rest_fn is not None and arity >= self._required_arity: return self._rest_fn + return None + + @jit.unroll_safe + def get_fn(self, arity): + fn = self._get_fn(arity) + if fn: + return fn + acc = [] - sorted = TimSort(self.get_arities()) + sorted = TimSort(self.get_arities()) sorted.sort() for x in sorted.list: acc.append(unicode(str(x))) @@ -183,6 +191,9 @@ def get_fn(self, arity): runtime_error(u"Wrong number of arguments " + unicode(str(arity)) + u" for function '" + unicode(self._name) + u"'. Expected " + join_last(acc, u"or"), u"pixie.stdlib/InvalidArityException") + + + def get_arities(self): return self._arities.keys() @@ -464,7 +475,9 @@ def deref(self): return self.get_root(self._rev) else: val = self.get_root(self._rev) - affirm(val is not undefined, u"Var " + self._name + u" is undefined") + if val is undefined: + pass + affirm(val is not undefined, u"Var " + self._ns + u"/" + self._name + u" is undefined") return val def is_defined(self): @@ -772,41 +785,6 @@ def invoke_k(self, args, stack): fn = self.get_fn(a, b, self._rev) return fn.invoke_k(args, stack) - -# class ElidableFn(object.Object): -# _type = object.Type(u"pixie.stdlib.ElidableFn") -# __immutable_fields__ = ["_boxed_fn"] -# def type(self): -# return ElidableFn._type -# -# def __init__(self, boxed_fn): -# self._boxed_fn = boxed_fn -# -# @elidable -# def _elidable_invoke_0(self, fn): -# return self._boxed_fn.invoke([]) -# -# @elidable -# def _elidable_invoke_1(self, fn, arg0): -# return self._boxed_fn.invoke([arg0]) -# -# @elidable -# def _elidable_invoke_2(self, fn, arg0, arg1): -# return self._boxed_fn.invoke([arg0, arg1]) -# -# -# def invoke(self, args): -# largs = jit.promote(len(args)) -# fn = self._boxed_fn.promote() -# if largs == 0: -# return self._elidable_invoke_0(fn).promote() -# elif largs == 1: -# return self._elidable_invoke_1(fn, args[0].promote()).promote() -# elif largs == 2: -# return self._elidable_invoke_2(fn, args[0].promote(), args[1].promote()).promote() -# affirm(False, u"Too many args to Elidable Fn") - - def munge(s): return s.replace("-", "_").replace("?", "_QMARK_").replace("!", "_BANG_") diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 614c4a01..b4262bb3 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -63,7 +63,7 @@ def __init__(self, ast, locals): self._c_locals = locals def call_continuation(self, val, stack): - ast = jit.promote(self._c_ast) + ast = self._c_ast return ast.interpret(val, self._c_locals, stack) def get_ast(self): @@ -77,7 +77,7 @@ def __init__(self, val, meta=nil): self._c_val = val def interpret(self, _, locals, stack): - return jit.promote(self._c_val), stack + return self._c_val, stack class Locals(object): _immutable_ = True @@ -124,8 +124,9 @@ def interpret(self, _, locals, stack): return InterpretedFn(self._c_name, self._c_args, locals_prefix, self._c_body), stack class InterpretedFn(code.BaseCode): - _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name"] + _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name", "_c_arg_names"] def __init__(self, name, arg_names, locals_prefix, ast): + code.BaseCode.__init__(self) self._c_arg_names = arg_names self._c_name = name if name is not nil: @@ -140,16 +141,15 @@ def invoke_k(self, args, stack): @jit.unroll_safe def invoke_k_with(self, args, stack, self_fn): # TODO: Check arg count - locals = jit.promote(self._c_locals) - locals = Locals(jit.promote(self._c_name), self_fn, locals) + locals = self._c_locals + locals = Locals(self._c_name, self_fn, locals) - arg_names = jit.promote(self._c_arg_names) - if not len(args) == len(arg_names): - runtime_error(u"Wrong number args, expected " + unicode(str(len(args))) + u" got " + unicode(str(len(arg_names))), + if not len(args) == len(self._c_arg_names): + runtime_error(u"Wrong number args, expected " + unicode(str(len(args))) + u" got " + unicode(str(len(self._c_arg_names))), u"pixie.stdlib.ArityException") - for idx in range(len(arg_names)): - locals = Locals(arg_names[idx], args[idx], locals) + for idx in range(len(self._c_arg_names)): + locals = Locals(self._c_arg_names[idx], args[idx], locals) return nil, stack_cons(stack, InterpretK(self._c_fn_ast, locals)) @@ -339,3 +339,55 @@ def __init__(self, var, meta=nil): def interpret(self, val, locals, stack): return self._c_var.deref(), stack + +from rpython.rlib.jit import JitDriver +from rpython.rlib.objectmodel import we_are_translated +def get_printable_location(ast): + return ast.get_short_location() + +jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) + +def run_stack(val, cont, stack=None): + stack = None + val = None + ast = cont.get_ast() + while True: + jitdriver.jit_merge_point(ast=ast, stack=stack, val=val, cont=cont) + try: + val, stack = cont.call_continuation(val, stack) + ast = cont.get_ast() + except BaseException as ex: + print_stacktrace(cont, stack) + if not we_are_translated(): + print ex + raise + break + + if stack: + cont = stack._cont + stack = stack._parent + else: + break + + if cont.should_enter_jit: + jitdriver.can_enter_jit(ast=ast, stack=stack, val=val, cont=cont) + + return val + +def stacktrace_for_cont(cont): + ast = cont.get_ast() + if ast: + return ast.get_long_location() + +def print_stacktrace(cont, stack): + st = [] + st.append(stacktrace_for_cont(cont)) + while stack: + st.append(stacktrace_for_cont(stack._cont)) + stack = stack._parent + st.reverse() + for line in st: + print line + + + diff --git a/pixie/vm2/numbers.py b/pixie/vm2/numbers.py index dee182f7..04c81183 100644 --- a/pixie/vm2/numbers.py +++ b/pixie/vm2/numbers.py @@ -29,9 +29,6 @@ def int_val(self): def r_uint_val(self): return r_uint(self._int_val) - def promote(self): - return Integer(jit.promote(self._int_val)) - def type(self): return Integer._type diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index c8f030cc..b4d81659 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -149,55 +149,8 @@ def __init__(self, cont, parent_stack): def stack_cons(stack, other): return StackCell(other, stack) -def get_printable_location(ast, old_ast): - return ast.get_short_location() - -from rpython.rlib.jit import JitDriver -jitdriver = JitDriver(greens=["ast", "prev_ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) - -def run_stack(val, cont, stack=None): - from pixie.vm2.interpreter import PrevASTNil - stack = None - val = None - ast = cont.get_ast() - prev_ast = PrevASTNil() - while True: - jitdriver.jit_merge_point(ast=ast, prev_ast=prev_ast, stack=stack, val=val, cont=cont) - try: - val, stack = cont.call_continuation(val, stack) - except BaseException as ex: - print_stacktrace(cont, stack) - if not we_are_translated(): - print ex - raise - break - if stack is None: - return val - prev_ast = ast - prev_cont = cont - cont = stack._cont - ast = cont.get_ast() - stack = stack._parent - - if prev_cont.should_enter_jit: - jitdriver.can_enter_jit(ast=ast, prev_ast=prev_ast, stack=stack, val=val, cont=cont) - - return val - -def stacktrace_for_cont(cont): - ast = cont.get_ast() - if ast: - return ast.get_long_location() - -def print_stacktrace(cont, stack): - st = [] - st.append(stacktrace_for_cont(cont)) - while stack: - st.append(stacktrace_for_cont(stack._cont)) - stack = stack._parent - st.reverse() - for line in st: - print line + + class RuntimeException(Object): _type = Type(u"pixie.stdlib.RuntimeException") diff --git a/target2.py b/target2.py index ca73db71..5b4e69f3 100644 --- a/target2.py +++ b/target2.py @@ -1,6 +1,7 @@ import pixie.vm2.interpreter as i -from pixie.vm2.object import StackCell, run_stack +from pixie.vm2.interpreter import run_stack +from pixie.vm2.object import StackCell import pixie.vm2.rt as rt from pixie.vm2.primitives import nil, true, false import pixie.vm2.code as code @@ -33,7 +34,7 @@ def entry_point(): val = testit(max) print val - return val + return 43 ## JIT STUFF @@ -93,6 +94,9 @@ def run_debug(argv): class DebugIFace(JitHookInterface): def on_abort(self, reason, jitdriver, greenkey, greenkey_repr, logops, operations): print "Aborted Trace, reason: ", Counters.counter_names[reason], logops, greenkey_repr + #from rpython.rlib.objectmodel import we_are_translated + #import pdb; pdb.set_trace() + #exit(0) pass def before_compile_bridge(self, debug_info): @@ -111,7 +115,7 @@ def jitpolicy(driver): def target(*args): import pixie.vm.rt as rt driver = args[0] - driver.exe_name = "pixie-vm" + driver.exe_name = "pixie-vm2" rt.__config__ = args[0].config From 321535a03edd8623a436c4866337a48dec2a3f0c Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sat, 30 May 2015 21:43:24 -0600 Subject: [PATCH 13/46] latest work on the new vm, started implementing a new pxic writer --- bootstrap.py | 5405 ---------------------------------------- pixie/bootstrap.pxi | 103 +- pixie/compiler.pxi | 103 +- pixie/io.pxi | 55 +- pixie/pxic-writer.pxi | 217 ++ pixie/stdlib.pxi | 2 +- pixie/streams/utf8.pxi | 21 +- target2.py | 4 +- 8 files changed, 421 insertions(+), 5489 deletions(-) delete mode 100755 bootstrap.py create mode 100644 pixie/pxic-writer.pxi diff --git a/bootstrap.py b/bootstrap.py deleted file mode 100755 index 76ddc220..00000000 --- a/bootstrap.py +++ /dev/null @@ -1,5405 +0,0 @@ -mid0 = (u""" `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm)))""", "pixie/compiler.pxi", 10) -mid1 = (u""" `(def ~x (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))""", "pixie/compiler.pxi", 12) -mid2 = (u"""(defprotocol ISeq""", "", 4) -mid3 = (u"""(defprotocol ISeqable""", "", 8) -mid4 = (u"""(defprotocol ICounted""", "", 11) -mid5 = (u"""(defprotocol IIndexed""", "", 14) -mid6 = (u"""(defprotocol IPersistentCollection""", "", 19) -mid7 = (u"""(defprotocol IEmpty""", "", 23) -mid8 = (u"""(defprotocol IObject""", "", 26) -mid9 = (u"""(defprotocol IReduce""", "", 32) -mid10 = (u"""(defprotocol IDeref""", "", 35) -mid11 = (u"""(defprotocol IReset""", "", 38) -mid12 = (u"""(defprotocol INamed""", "", 41) -mid13 = (u"""(defprotocol IAssociative""", "", 45) -mid14 = (u"""(defprotocol ILookup""", "", 50) -mid15 = (u"""(defprotocol IMapEntry""", "", 53) -mid16 = (u"""(defprotocol IStack""", "", 57) -mid17 = (u"""(defprotocol IPop""", "", 60) -mid18 = (u"""(defprotocol IFn""", "", 63) -mid19 = (u"""(defprotocol IDoc""", "", 66) -mid20 = (u"""(defprotocol IMeta""", "", 73) -mid21 = (u"""(defprotocol ITransientCollection""", "", 77) -mid22 = (u"""(defprotocol IToTransient""", "", 80) -mid23 = (u"""(defprotocol ITransientStack""", "", 83) -mid24 = (u"""(defprotocol IDisposable""", "", 87) -mid25 = (u"""(defprotocol IMessageObject""", "", 90) -mid26 = (u"""(extend -get-field Object -internal-get-field)""", "", 96) -mid27 = (u""" (-eq [this other]""", "", 106) -mid28 = (u"""(extend-type Object""", "", 99) -mid29 = (u""" (-repr [x sb]""", "", 103) -mid30 = (u""" (sb (-internal-to-repr x)))""", "", 104) -mid31 = (u""" (-str [x sb]""", "", 100) -mid32 = (u""" (sb (-internal-to-str x)))""", "", 101) -mid33 = (u""" (-str [this sb]""", "", 111) -mid34 = (u"""(extend-type String""", "", 109) -mid35 = (u""" (sb this)))""", "", 112) -mid36 = (u"""(extend -eq Number -num-eq)""", "", 116) -mid37 = (u""" ([x] x)""", "", 123) -mid38 = (u""" ([x y] (-add x y))""", "", 124) -mid39 = (u""" (-apply + (+ x y) more)))""", "", 126) -mid40 = (u""" ([x] x)""", "", 130) -mid41 = (u""" ([x y] (-sub x y))""", "", 131) -mid42 = (u""" (-apply - (- x y) more))) """, "", 133) -mid43 = (u""" ([x] (+ x 1)))""", "", 136) -mid44 = (u""" ([x] (- x 1)))""", "", 139) -mid45 = (u""" ([x y] (-lt x y))""", "", 142) -mid46 = (u""" (-apply < (< x y) more)))""", "", 144) -mid47 = (u""" ([x y] (-gt x y))""", "", 147) -mid48 = (u""" (-apply > (> x y) more)))""", "", 149) -mid49 = (u""" ([x y] (-lte x y))""", "", 154) -mid50 = (u""" ([x y & rest] (if (-lte x y)""", "", 155) -mid51 = (u""" (apply <= y rest)""", "", 156) -mid52 = (u""" ([x y] (-gte x y))""", "", 161) -mid53 = (u""" ([x y & rest] (if (-gte x y)""", "", 162) -mid54 = (u""" (apply >= y rest)""", "", 163) -mid55 = (u""" ([x y] (if (identical? x y)""", "", 173) -mid56 = (u""" (-eq x y)))""", "", 175) -mid57 = (u""" ([x y & rest] (if (eq x y)""", "", 176) -mid58 = (u""" (apply = y rest)""", "", 177) -mid59 = (u""" ([coll] coll)""", "", 182) -mid60 = (u""" ([coll itm] (-conj coll itm))""", "", 183) -mid61 = (u""" (-apply conj (conj x y) more)))""", "", 185) -mid62 = (u""" ([coll idx not-found] (-nth-not-found coll idx not-found)))""", "", 194) -mid63 = (u""" ([coll idx] (-nth coll idx))""", "", 193) -mid64 = (u""" ([coll] (-count coll)))""", "", 198) -mid65 = (u"""(deftype Cons [first next meta]""", "", 201) -mid66 = (u""" (-first [this] first)""", "", 203) -mid67 = (u""" (-next [this] next)""", "", 204) -mid68 = (u""" (-seq [this] this)""", "", 206) -mid69 = (u""" (-meta [this] meta)""", "", 208) -mid70 = (u""" (-with-meta [this new-meta]""", "", 209) -mid71 = (u""" (->Cons first next new-meta)))""", "", 210) -mid72 = (u""" (->Cons head (seq tail) nil))""", "", 213) -mid73 = (u""" ([] (-string-builder))""", "", 218) -mid74 = (u""" ([sb] (-str sb))""", "", 219) -mid75 = (u""" (if (instance? String x)""", "", 221) -mid76 = (u""" (-add-to-string-builder x)""", "", 222) -mid77 = (u""" (-add-to-string-bulder (-str x)))))""", "", 223) -mid78 = (u""" (transduce""", "", 226) -mid79 = (u""" (map str)""", "", 227) -mid80 = (u""" string-builder""", "", 228) -mid81 = (u""" args))""", "", 229) -mid82 = (u""" (let [sb (-string-builder)""", "", 232) -mid83 = (u""" (-add-to-string-builder sb x))]""", "", 234) -mid84 = (u""" sb sb]""", "", 236) -mid85 = (u""" (loop [idx 0""", "", 235) -mid86 = (u""" (if (< idx (count args))""", "", 237) -mid87 = (u""" (recur (inc idx)""", "", 238) -mid88 = (u""" (do (-str (aget args idx) add-fn)""", "", 239) -mid89 = (u""" (add-fn " ")""", "", 240) -mid90 = (u""" sb))""", "", 241) -mid91 = (u""" (-blocking-println (-finish-string-builder sb))))""", "", 242) -mid92 = (u""" (if (-satisfies? ISeqable t)""", "", 256) -mid93 = (u""" (let [ts (seq t)]""", "", 257) -mid94 = (u""" (if (not ts) false""", "", 258) -mid95 = (u""" (if (-instance? (first ts) x)""", "", 259) -mid96 = (u""" (instance? (rest ts) x))))""", "", 261) -mid97 = (u""" (-instance? t x)))""", "", 262) -mid98 = (u"""(deftype Reduced [x]""", "", 268) -mid99 = (u""" (-deref [this] x))""", "", 270) -mid100 = (u""" (->Reduced x))""", "", 273) -mid101 = (u""" (instance? Reduced x))""", "", 276) -mid102 = (u""" (if (-satisfies? ISeqable p)""", "", 289) -mid103 = (u""" (let [ps (seq p)]""", "", 290) -mid104 = (u""" (if (not ps) true""", "", 291) -mid105 = (u""" (if (not (-satisfies? (first ps) x))""", "", 292) -mid106 = (u""" (satisfies? (rest ps) x))))""", "", 294) -mid107 = (u""" (-satisfies? p x)))""", "", 295) -mid108 = (u""" (let [f (xform rf)""", "", 306) -mid109 = (u""" result (-reduce coll f (f))]""", "", 307) -mid110 = (u""" (f result)))""", "", 308) -mid111 = (u""" (let [result (-reduce coll f (f))]""", "", 303) -mid112 = (u""" (f result)))""", "", 304) -mid113 = (u""" (let [f (xform rf)""", "", 310) -mid114 = (u""" result (-reduce coll f init)]""", "", 311) -mid115 = (u""" (f result))))""", "", 312) -mid116 = (u""" (-reduce col rf init)))""", "", 318) -mid117 = (u""" (reduce rf (rf) col))""", "", 316) -mid118 = (u""" (if (satisfies? IToTransient to)""", "", 329) -mid119 = (u""" (transduce xform conj! (transient to) from)""", "", 330) -mid120 = (u""" (transduce xform conj to from))))""", "", 331) -mid121 = (u""" (if (satisfies? IToTransient to)""", "", 325) -mid122 = (u""" (persistent! (reduce conj! (transient to) from))""", "", 326) -mid123 = (u""" (reduce conj to from)))""", "", 327) -mid124 = (u""" ([] (xf))""", "", 340) -mid125 = (u""" ([result] (xf result))""", "", 341) -mid126 = (u""" ([result item] (xf result (f item))))))""", "", 342) -mid127 = (u""" (lazy-seq*""", "", 344) -mid128 = (u""" (let [s (seq coll)]""", "", 346) -mid129 = (u""" (if s""", "", 347) -mid130 = (u""" (cons (f (first s))""", "", 348) -mid131 = (u""" (map f (rest s)))""", "", 349) -mid132 = (u""" (lazy-seq*""", "", 353) -mid133 = (u""" (let [ss (map seq cs)]""", "", 355) -mid134 = (u""" (if (every? identity ss)""", "", 356) -mid135 = (u""" (cons (map first ss) (step (map rest ss)))""", "", 357) -mid136 = (u""" (map (fn [args] (apply f args)) (step colls)))))""", "", 359) -mid137 = (u""" (let [step (fn step [cs]""", "", 352) -mid138 = (u"""(deftype Range [start stop step]""", "", 367) -mid139 = (u""" (-reduce [self f init]""", "", 369) -mid140 = (u""" acc init]""", "", 371) -mid141 = (u""" (loop [i start""", "", 370) -mid142 = (u""" (if (or (and (> step 0) (< i stop))""", "", 372) -mid143 = (u""" (and (< step 0) (> i stop))""", "", 373) -mid144 = (u""" (and (= step 0)))""", "", 374) -mid145 = (u""" (let [acc (f acc i)]""", "", 375) -mid146 = (u""" (if (reduced? acc)""", "", 376) -mid147 = (u""" @acc""", "", 377) -mid148 = (u""" (recur (+ i step) acc)))""", "", 378) -mid149 = (u""" acc)))""", "", 379) -mid150 = (u""" (-count [self]""", "", 381) -mid151 = (u""" (if (or (and (< start stop) (< step 0))""", "", 382) -mid152 = (u""" (and (> start stop) (> step 0))""", "", 383) -mid153 = (u""" (= step 0))""", "", 384) -mid154 = (u""" (abs (quot (- start stop) step))))""", "", 386) -mid155 = (u""" (-nth [self idx]""", "", 388) -mid156 = (u""" (when (or (= start stop 0) (neg? idx))""", "", 389) -mid157 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))""", "", 390) -mid158 = (u""" (let [cmp (if (< start stop) < >)""", "", 391) -mid159 = (u""" val (+ start (* idx step))]""", "", 392) -mid160 = (u""" (if (cmp val stop)""", "", 393) -mid161 = (u""" val""", "", 394) -mid162 = (u""" (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]))))""", "", 395) -mid163 = (u""" (-nth-not-found [self idx not-found]""", "", 396) -mid164 = (u""" (let [cmp (if (< start stop) < >)""", "", 397) -mid165 = (u""" val (+ start (* idx step))]""", "", 398) -mid166 = (u""" (if (cmp val stop)""", "", 399) -mid167 = (u""" val""", "", 400) -mid168 = (u""" not-found)))""", "", 401) -mid169 = (u""" (-seq [self]""", "", 403) -mid170 = (u""" (when (or (and (> step 0) (< start stop))""", "", 404) -mid171 = (u""" (and (< step 0) (> start stop)))""", "", 405) -mid172 = (u""" (cons start (lazy-seq* #(range (+ start step) stop step)))))""", "", 406) -mid173 = (u""" (-str [this sbf]""", "", 408) -mid174 = (u""" (-str (seq this) sbf))""", "", 409) -mid175 = (u""" (-repr [this sbf]""", "", 410) -mid176 = (u""" (-repr (seq this) sbf))""", "", 411) -mid177 = (u""" (-eq [this sb]""", "", 412) -mid178 = (u""" ([] (pixie.stdlib.range/->Range 0 MAX-NUMBER 1))""", "", 427) -mid179 = (u""" ([stop] (pixie.stdlib.range/->Range 0 stop 1))""", "", 428) -mid180 = (u""" ([start stop step] (pixie.stdlib.range/->Range start stop step)))""", "", 430) -mid181 = (u""" ([start stop] (pixie.stdlib.range/->Range start stop 1))""", "", 429) -mid182 = (u"""(deftype Node [edit array]""", "", 436) -mid183 = (u""" (-get-field [this name]""", "", 438) -mid184 = (u""" (get-field this name)))""", "", 439) -mid185 = (u""" (new-node edit (make-array 32)))""", "", 443) -mid186 = (u""" (->Node edit array)))""", "", 445) -mid187 = (u"""(def EMPTY-NODE (new-node nil))""", "", 447) -mid188 = (u""" (analyze-form (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw)""", "pixie/compiler.pxi", 307) -mid189 = (u""" (let [cnt (.-cnt this)]""", "", 452) -mid190 = (u""" (if (< cnt 32)""", "", 453) -mid191 = (u""" (bit-shift-left (bit-shift-right (dec cnt) 5) 5))))""", "", 455) -mid192 = (u""" (if (and (<= 0 i) (< i (.-cnt this)))""", "", 458) -mid193 = (u""" (if (>= i (tailoff this))""", "", 459) -mid194 = (u""" (.-tail this)""", "", 460) -mid195 = (u""" (loop [node (.-root this)""", "", 461) -mid196 = (u""" level (.-shift this)]""", "", 462) -mid197 = (u""" (if (> level 0)""", "", 463) -mid198 = (u""" (recur (aget (.-array node)""", "", 464) -mid199 = (u""" (bit-and (bit-shift-right i level) 0x01f))""", "", 465) -mid200 = (u""" (- level 5))""", "", 466) -mid201 = (u""" (.-array node))))""", "", 467) -mid202 = (u""" (throw [:pixie.stdlib/IndexOutOfRangeException""", "", 468) -mid203 = (u"""(deftype PersistentVector [cnt shift root tail meta]""", "", 471) -mid204 = (u""" (-get-field [this name]""", "", 473) -mid205 = (u""" (get-field this name))""", "", 474) -mid206 = (u""" (-conj [this val]""", "", 477) -mid207 = (u""" (assert (< cnt 0xFFFFFFFF) "Vector too large")""", "", 478) -mid208 = (u""" (if (< (- cnt (tailoff this)) 32)""", "", 480) -mid209 = (u""" (let [new-tail (array-append tail val)]""", "", 481) -mid210 = (u""" (->PersistentVector (inc cnt) shift root new-tail meta))""", "", 482) -mid211 = (u""" (let [tail-node (->Node (.-edit root) tail)]""", "", 484) -mid212 = (u""" (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift))""", "", 485) -mid213 = (u""" (let [new-root (new-node (.-edit root))""", "", 487) -mid214 = (u""" new-root-arr (.-array new-root)]""", "", 488) -mid215 = (u""" (aset new-root-arr 0 root)""", "", 489) -mid216 = (u""" (aset new-root-arr 1 (new-path (.-edit root) shift tail-node))""", "", 490) -mid217 = (u""" (->PersistentVector (inc cnt)""", "", 491) -mid218 = (u""" (+ shift 5)""", "", 492) -mid219 = (u""" new-root""", "", 493) -mid220 = (u""" (array val)""", "", 494) -mid221 = (u""" (let [new-root (push-tail this shift root tail-node)]""", "", 496) -mid222 = (u""" (->PersistentVector (inc cnt)""", "", 497) -mid223 = (u""" new-root""", "", 499) -mid224 = (u""" (array val)""", "", 500) -mid225 = (u""" (-nth [self i]""", "", 503) -mid226 = (u""" (if (and (<= 0 i)""", "", 504) -mid227 = (u""" (< i cnt))""", "", 505) -mid228 = (u""" (let [node (array-for self i)]""", "", 506) -mid229 = (u""" (aget node (bit-and i 0x01F)))""", "", 507) -mid230 = (u""" (throw [:pixie.stdlib/IndexOutOfRange""", "", 508) -mid231 = (u""" (str "Index out of range, got " i " only have " cnt)])))""", "", 509) -mid232 = (u""" (-nth-not-found [self i not-found]""", "", 511) -mid233 = (u""" (if (and (<= 0 i)""", "", 512) -mid234 = (u""" (< i cnt))""", "", 513) -mid235 = (u""" (let [node (array-for self i)]""", "", 514) -mid236 = (u""" (aget node (bit-and i 0x01F)))""", "", 515) -mid237 = (u""" not-found))""", "", 516) -mid238 = (u""" (-get [this val]""", "", 521) -mid239 = (u""" (-nth-not-found self val nil))""", "", 522) -mid240 = (u""" (-count [this] cnt)""", "", 526) -mid241 = (u""" (-pop [this]""", "", 529) -mid242 = (u""" (assert (!= cnt) "Can't pop an empty vector")""", "", 530) -mid243 = (u""" (if (== cnt 1)""", "", 532) -mid244 = (u""" EMPTY""", "", 533) -mid245 = (u""" (if (> (- cnt (tailoff this)) 1)""", "", 534) -mid246 = (u""" (let [size (dec (count tail))""", "", 535) -mid247 = (u""" new-tail (array-resize size)]""", "", 536) -mid248 = (u""" (->PersistentVector (dec cnt)""", "", 537) -mid249 = (u""" new-tail""", "", 540) -mid250 = (u""" (let [new-tail (array-for this (- cnt 2))""", "", 542) -mid251 = (u""" new-root (pop-tail shift root)]""", "", 543) -mid252 = (u""" (nil? new-root)""", "", 545) -mid253 = (u""" (->PersisentVector (dec cnt)""", "", 546) -mid254 = (u""" EMPTY-NODE""", "", 548) -mid255 = (u""" new-tail""", "", 549) -mid256 = (u""" (and (> shift 5)""", "", 551) -mid257 = (u""" (nil? (aget (.-array new-root) 1)))""", "", 552) -mid258 = (u""" (->PersistentVector (dec cnt)""", "", 553) -mid259 = (u""" (- shift 5)""", "", 554) -mid260 = (u""" (aget (.-array new-root) 0)""", "", 555) -mid261 = (u""" new-tail""", "", 556) -mid262 = (u""" (->PersistentVector (dec cnt)""", "", 560) -mid263 = (u""" new-root""", "", 562) -mid264 = (u""" new-tail""", "", 563) -mid265 = (u""" (cond""", "", 544) -mid266 = (u""" (let [subidx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01f)""", "", 568) -mid267 = (u""" ret-array (array-clone (.-array parent))""", "", 569) -mid268 = (u""" node-to-insert (if (= level 5)""", "", 570) -mid269 = (u""" tail-node""", "", 571) -mid270 = (u""" (let [child (aget (.-array parent) subidx)]""", "", 572) -mid271 = (u""" (if (= child nil)""", "", 573) -mid272 = (u""" (new-path (.-edit (.-root this))""", "", 574) -mid273 = (u""" (- level 5)""", "", 575) -mid274 = (u""" tail-node)""", "", 576) -mid275 = (u""" (push-tail this""", "", 577) -mid276 = (u""" (- level 5)""", "", 578) -mid277 = (u""" child""", "", 579) -mid278 = (u""" tail-node))))]""", "", 580) -mid279 = (u""" (aset ret-array subidx node-to-insert)""", "", 581) -mid280 = (u""" (->Node (.-edit parent) ret-array)))""", "", 582) -mid281 = (u""" (let [sub-idx (bit-and (bit-shift-right (dec (.-cnt)) level) 0x01F)]""", "", 585) -mid282 = (u""" (> level 5)""", "", 587) -mid283 = (u""" (let [new-child (pop-tail (- level 5)""", "", 588) -mid284 = (u""" (aget (.-array node) sub-idx))]""", "", 589) -mid285 = (u""" (if (or (nil? new-child)""", "", 590) -mid286 = (u""" (= sub-idx 0))""", "", 591) -mid287 = (u""" (let [root (.-root this)""", "", 593) -mid288 = (u""" ret (->Node (.-edit root)""", "", 594) -mid289 = (u""" (.-array node))]""", "", 595) -mid290 = (u""" (aset (.-array ret) sub-idx new-child)""", "", 596) -mid291 = (u""" ret)))""", "", 597) -mid292 = (u""" (= sub-idx 0)""", "", 599) -mid293 = (u""" (let [root (.-root this)""", "", 603) -mid294 = (u""" ret (->Node (.-edit root)""", "", 604) -mid295 = (u""" (aclone (.-array node)))]""", "", 605) -mid296 = (u""" (aset (.-array ret) nil)""", "", 606) -mid297 = (u""" ret))))""", "", 607) -mid298 = (u""" (cond""", "", 586) -mid299 = (u""" (if (= level 0)""", "", 610) -mid300 = (u""" node""", "", 611) -mid301 = (u""" (let [nnode (new-node edit)]""", "", 612) -mid302 = (u""" (aset (.-array nnode) 0 (new-path edit (- level 5) node))""", "", 613) -mid303 = (u""" nnode)))""", "", 614) -mid304 = (u"""(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil))""", "", 617) -mid305 = (u""" (if (< (count arr) 32)""", "", 620) -mid306 = (u""" (->PersistentVector (count arr) 5 EMPTY-NODE arr nil)""", "", 621) -mid307 = (u""" (into [] arr)))""", "", 622) -mid308 = (u""" (-reduce [this f init]""", "", 636) -mid309 = (u"""(extend-type Array""", "", 626) -mid310 = (u""" acc init]""", "", 638) -mid311 = (u""" (loop [idx 0""", "", 637) -mid312 = (u""" (if (reduced? acc)""", "", 639) -mid313 = (u""" @acc""", "", 640) -mid314 = (u""" (if (< idx (count this))""", "", 641) -mid315 = (u""" (recur (inc idx)""", "", 642) -mid316 = (u""" (f acc (aget this idx)))""", "", 643) -mid317 = (u""" acc)))))""", "", 644) -mid318 = (u""" (-count ([arr]""", "", 632) -mid319 = (u""" (.-count arr)))""", "", 633) -mid320 = (u""" (-conj [arr itm]""", "", 628) -mid321 = (u""" (conj (vector-from-array arr) itm))""", "", 629) -mid322 = (u""" (loop [idx 0]""", "", 647) -mid323 = (u""" (when (< idx size)""", "", 648) -mid324 = (u""" (do (aset to (+ to-idx idx) (aget from (+ from-idx idx)))""", "", 649) -mid325 = (u""" (recur (inc idx))))))""", "", 650) -mid326 = (u""" (let [new-array (make-array (inc (count arr)))]""", "", 653) -mid327 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 654) -mid328 = (u""" (aset new-array (count arr) val)""", "", 655) -mid329 = (u""" new-array))""", "", 656) -mid330 = (u""" (let [new-array (make-array (count arr))]""", "", 659) -mid331 = (u""" (array-copy arr 0 new-array 0 (count arr))""", "", 660) -mid332 = (u""" new-array))""", "", 661) -mid333 = (u""" v (into [] (range MAX))]""", "", 666) -mid334 = (u""" (dotimes [x MAX]""", "", 667) -mid335 = (u""" (println x)""", "", 668) -mid336 = (u""" (assert (= x (nth v x)))))""", "", 669) -mid337 = (u"""(let [MAX 1024""", "", 665) -mid338 = (u"""(do ;; This file is used to build what we need to even start running stdlib.pxi""", "", 1) - - -code_ast=i.Do( - args=[ - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/ISeq) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"ISeq")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"ISeq")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-first) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-first")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-first")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid2, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-next) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-next")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-next")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeq"), meta=i.Meta(mid2, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid2, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/ISeqable) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"ISeqable")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"ISeqable")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-seq) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-seq")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-seq")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid3, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid3, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/ICounted) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"ICounted")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"ICounted")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-count) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-count")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-count")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ICounted"), meta=i.Meta(mid4, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid4, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IIndexed) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IIndexed")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IIndexed")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-nth) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-nth")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-nth")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid5, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-nth-not-found) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-nth-not-found")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-nth-not-found")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IIndexed"), meta=i.Meta(mid5, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid5, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IPersistentCollection) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IPersistentCollection")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IPersistentCollection")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-conj) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-conj")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-conj")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid6, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-disj) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-disj")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-disj")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IPersistentCollection"), meta=i.Meta(mid6, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid6, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IEmpty) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IEmpty")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IEmpty")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-empty) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-empty")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-empty")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IEmpty"), meta=i.Meta(mid7, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid7, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IObject) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IObject")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IObject")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-hash) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-hash")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-hash")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-eq) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-eq")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-eq")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-str) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-str")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-str")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-repr) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-repr")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-repr")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IObject"), meta=i.Meta(mid8, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid8, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IReduce) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IReduce")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IReduce")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-reduce) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-reduce")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-reduce")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IReduce"), meta=i.Meta(mid9, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid9, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IDeref) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IDeref")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IDeref")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-deref) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-deref")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-deref")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IDeref"), meta=i.Meta(mid10, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid10, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IReset) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IReset")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IReset")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-reset!) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-reset!")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-reset!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IReset"), meta=i.Meta(mid11, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid11, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/INamed) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"INamed")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"INamed")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-namespace) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-namespace")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-namespace")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid12, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-name) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-name")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-name")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"INamed"), meta=i.Meta(mid12, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid12, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IAssociative) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IAssociative")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IAssociative")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-assoc) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-assoc")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-assoc")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid13, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-contains-key) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-contains-key")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-contains-key")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid13, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-dissoc) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-dissoc")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-dissoc")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IAssociative"), meta=i.Meta(mid13, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid13, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/ILookup) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"ILookup")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"ILookup")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-get) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-get")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-get")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ILookup"), meta=i.Meta(mid14, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid14, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IMapEntry) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IMapEntry")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IMapEntry")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-key) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-key")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-key")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid15, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-val) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-val")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-val")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMapEntry"), meta=i.Meta(mid15, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid15, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IStack) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IStack")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IStack")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-push) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-push")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-push")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IStack"), meta=i.Meta(mid16, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid16, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IPop) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IPop")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IPop")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-pop) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-pop")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-pop")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IPop"), meta=i.Meta(mid17, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid17, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IFn) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IFn")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IFn")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-invoke) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-invoke")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-invoke")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IFn"), meta=i.Meta(mid18, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid18, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IDoc) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IDoc")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IDoc")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-doc) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-doc")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-doc")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IDoc"), meta=i.Meta(mid19, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid19, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/IVector) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IVector")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IVector")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/ISequential) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"ISequential")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"ISequential")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/IMap) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IMap")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IMap")), - ], - meta=nil)]), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IMeta) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IMeta")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IMeta")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-with-meta) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-with-meta")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-with-meta")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid20, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-meta) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-meta")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-meta")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMeta"), meta=i.Meta(mid20, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid20, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/ITransientCollection) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"ITransientCollection")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"ITransientCollection")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-conj!) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-conj!")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-conj!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientCollection"), meta=i.Meta(mid21, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid21, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IToTransient) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IToTransient")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IToTransient")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-transient) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-transient")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-transient")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid22, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid22, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/ITransientStack) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"ITransientStack")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"ITransientStack")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-push!) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-push!")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-push!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid23, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-pop!) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-pop!")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-pop!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ITransientStack"), meta=i.Meta(mid23, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid23, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IDisposable) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IDisposable")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IDisposable")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-dispose!) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-dispose!")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-dispose!")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IDisposable"), meta=i.Meta(mid24, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid24, 1)), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/IMessageObject) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"IMessageObject")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"protocol"), meta=i.Meta(mid0, 22)), - i.Const(rt.wrap(u"IMessageObject")), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-get-field) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-get-field")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-get-field")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid25, 14)), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/-invoke-method) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-invoke-method")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"polymorphic-fn"), meta=i.Meta(mid1, 31)), - i.Const(rt.wrap(u"-invoke-method")), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IMessageObject"), meta=i.Meta(mid25, 14)), - ], - meta=nil)]), - ], - meta=i.Meta(mid25, 1)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid26, 2)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid26, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid26, 20)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-get-field"), meta=i.Meta(mid26, 27)), - ], - meta=i.Meta(mid26, 1)), - i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid27, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid28, 14)), - i.Fn(args=[kw(u"this"),kw(u"other")],name=kw(u"fn_360"), - body=i.Const(false), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid29, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid28, 14)), - i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_363"), - body=i.TailCall( - args=[ - i.Lookup(kw(u"sb"), meta=i.Meta(mid30, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-repr"), meta=i.Meta(mid30, 10)), - i.Lookup(kw(u"x"), meta=i.Meta(mid30, 28)), - ], - meta=i.Meta(mid30, 9)), - ], - meta=i.Meta(mid30, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid31, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Object"), meta=i.Meta(mid28, 14)), - i.Fn(args=[kw(u"x"),kw(u"sb")],name=kw(u"fn_357"), - body=i.TailCall( - args=[ - i.Lookup(kw(u"sb"), meta=i.Meta(mid32, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-internal-to-str"), meta=i.Meta(mid32, 10)), - i.Lookup(kw(u"x"), meta=i.Meta(mid32, 27)), - ], - meta=i.Meta(mid32, 9)), - ], - meta=i.Meta(mid32, 5)), - ), - ], - meta=nil), - ], - meta=i.Meta(mid28, 1)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid33, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid34, 14)), - i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"fn_366"), - body=i.TailCall( - args=[ - i.Lookup(kw(u"sb"), meta=i.Meta(mid35, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid35, 9)), - ], - meta=i.Meta(mid35, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=i.Meta(mid36, 2)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid36, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Number"), meta=i.Meta(mid36, 13)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-num-eq"), meta=i.Meta(mid36, 20)), - ], - meta=i.Meta(mid36, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/+) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"+")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"+")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"+"), - body=i.Const(rt.wrap(0)), - ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"+"), - body=i.Lookup(kw(u"x"), meta=i.Meta(mid37, 8)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"+"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add"), meta=i.Meta(mid38, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid38, 16)), - i.Lookup(kw(u"y"), meta=i.Meta(mid38, 18)), - ], - meta=i.Meta(mid38, 10)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"+"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid39, 5)), - i.Lookup(kw(u"+"), meta=i.Meta(mid39, 12)), - i.Invoke( - args=[ - i.Lookup(kw(u"+"), meta=i.Meta(mid39, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid39, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid39, 19)), - ], - meta=i.Meta(mid39, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid39, 22)), - ], - meta=i.Meta(mid39, 4)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/-) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"-")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"-")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"-"), - body=i.Const(rt.wrap(0)), - ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"-"), - body=i.Lookup(kw(u"x"), meta=i.Meta(mid40, 8)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"-"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-sub"), meta=i.Meta(mid41, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid41, 16)), - i.Lookup(kw(u"y"), meta=i.Meta(mid41, 18)), - ], - meta=i.Meta(mid41, 10)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"-"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid42, 5)), - i.Lookup(kw(u"-"), meta=i.Meta(mid42, 12)), - i.Invoke( - args=[ - i.Lookup(kw(u"-"), meta=i.Meta(mid42, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid42, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid42, 19)), - ], - meta=i.Meta(mid42, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid42, 22)), - ], - meta=i.Meta(mid42, 4)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/inc) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"inc")), - i.Fn(args=[kw(u"x")],name=kw(u"inc"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid43, 9)), - i.Lookup(kw(u"x"), meta=i.Meta(mid43, 11)), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid43, 8)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/dec) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"dec")), - i.Fn(args=[kw(u"x")],name=kw(u"dec"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid44, 9)), - i.Lookup(kw(u"x"), meta=i.Meta(mid44, 11)), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid44, 8)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/<) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"<")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"<")), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"<"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-lt"), meta=i.Meta(mid45, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid45, 15)), - i.Lookup(kw(u"y"), meta=i.Meta(mid45, 17)), - ], - meta=i.Meta(mid45, 10)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u"<"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid46, 5)), - i.Lookup(kw(u"<"), meta=i.Meta(mid46, 12)), - i.Invoke( - args=[ - i.Lookup(kw(u"<"), meta=i.Meta(mid46, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid46, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid46, 19)), - ], - meta=i.Meta(mid46, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid46, 22)), - ], - meta=i.Meta(mid46, 4)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/>) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u">")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u">")), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u">"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-gt"), meta=i.Meta(mid47, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid47, 15)), - i.Lookup(kw(u"y"), meta=i.Meta(mid47, 17)), - ], - meta=i.Meta(mid47, 10)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"more")],name=kw(u">"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid48, 5)), - i.Lookup(kw(u">"), meta=i.Meta(mid48, 12)), - i.Invoke( - args=[ - i.Lookup(kw(u">"), meta=i.Meta(mid48, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid48, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid48, 19)), - ], - meta=i.Meta(mid48, 14)), - i.Lookup(kw(u"more"), meta=i.Meta(mid48, 22)), - ], - meta=i.Meta(mid48, 4)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/<=) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"<=")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"<=")), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"<="), - body=i.Const(true), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"<="), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-lte"), meta=i.Meta(mid49, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid49, 16)), - i.Lookup(kw(u"y"), meta=i.Meta(mid49, 18)), - ], - meta=i.Meta(mid49, 10)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"rest")],name=kw(u"<="), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-lte"), meta=i.Meta(mid50, 22)), - i.Lookup(kw(u"x"), meta=i.Meta(mid50, 27)), - i.Lookup(kw(u"y"), meta=i.Meta(mid50, 29)), - ], - meta=i.Meta(mid50, 21)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid51, 20)), - i.Lookup(kw(u"<="), meta=i.Meta(mid51, 26)), - i.Lookup(kw(u"y"), meta=i.Meta(mid51, 29)), - i.Lookup(kw(u"rest"), meta=i.Meta(mid51, 31)), - ], - meta=i.Meta(mid51, 19)), - els=i.Const(nil), - meta=i.Meta(mid50, 17)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/>=) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u">=")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u">=")), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u">="), - body=i.Const(true), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u">="), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-gte"), meta=i.Meta(mid52, 11)), - i.Lookup(kw(u"x"), meta=i.Meta(mid52, 16)), - i.Lookup(kw(u"y"), meta=i.Meta(mid52, 18)), - ], - meta=i.Meta(mid52, 10)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"rest")],name=kw(u">="), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-gte"), meta=i.Meta(mid53, 22)), - i.Lookup(kw(u"x"), meta=i.Meta(mid53, 27)), - i.Lookup(kw(u"y"), meta=i.Meta(mid53, 29)), - ], - meta=i.Meta(mid53, 21)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid54, 20)), - i.Lookup(kw(u">="), meta=i.Meta(mid54, 26)), - i.Lookup(kw(u"y"), meta=i.Meta(mid54, 29)), - i.Lookup(kw(u"rest"), meta=i.Meta(mid54, 31)), - ], - meta=i.Meta(mid54, 19)), - els=i.Const(nil), - meta=i.Meta(mid53, 17)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/=) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"=")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"=")), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"x")],name=kw(u"="), - body=i.Const(true), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"x"),kw(u"y")],name=kw(u"="), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"identical?"), meta=i.Meta(mid55, 15)), - i.Lookup(kw(u"x"), meta=i.Meta(mid55, 26)), - i.Lookup(kw(u"y"), meta=i.Meta(mid55, 28)), - ], - meta=i.Meta(mid55, 14)), - then=i.Const(true), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid56, 13)), - i.Lookup(kw(u"x"), meta=i.Meta(mid56, 17)), - i.Lookup(kw(u"y"), meta=i.Meta(mid56, 19)), - ], - meta=i.Meta(mid56, 12)), - meta=i.Meta(mid55, 10)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"x"),kw(u"y"),kw(u"rest")],name=kw(u"="), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"eq"), meta=i.Meta(mid57, 22)), - i.Lookup(kw(u"x"), meta=i.Meta(mid57, 25)), - i.Lookup(kw(u"y"), meta=i.Meta(mid57, 27)), - ], - meta=i.Meta(mid57, 21)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid58, 20)), - i.Lookup(kw(u"="), meta=i.Meta(mid58, 26)), - i.Lookup(kw(u"y"), meta=i.Meta(mid58, 28)), - i.Lookup(kw(u"rest"), meta=i.Meta(mid58, 30)), - ], - meta=i.Meta(mid58, 19)), - els=i.Const(nil), - meta=i.Meta(mid57, 17)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/conj) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"conj")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"conj")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"conj"), - body=i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), - ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"coll")],name=kw(u"conj"), - body=i.Lookup(kw(u"coll"), meta=i.Meta(mid59, 11)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"coll"),kw(u"itm")],name=kw(u"conj"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid60, 16)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid60, 22)), - i.Lookup(kw(u"itm"), meta=i.Meta(mid60, 27)), - ], - meta=i.Meta(mid60, 15)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(2)), - i.Fn(args=[kw(u"coll"),kw(u"item"),kw(u"more")],name=kw(u"conj"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-apply"), meta=i.Meta(mid61, 5)), - i.Lookup(kw(u"conj"), meta=i.Meta(mid61, 12)), - i.Invoke( - args=[ - i.Lookup(kw(u"conj"), meta=i.Meta(mid61, 18)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"x"), meta=i.Meta(mid61, 23)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"y"), meta=i.Meta(mid61, 25)), - ], - meta=i.Meta(mid61, 17)), - i.Lookup(kw(u"more"), meta=i.Meta(mid61, 28)), - ], - meta=i.Meta(mid61, 4)), - )]) - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/nth) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"nth")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"nth")), - i.Const(rt.wrap(3)), i.Fn(args=[kw(u"coll"),kw(u"idx"),kw(u"not-found")],name=kw(u"nth"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid62, 26)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid62, 41)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid62, 46)), - i.Lookup(kw(u"not-found"), meta=i.Meta(mid62, 50)), - ], - meta=i.Meta(mid62, 25)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"coll"),kw(u"idx")],name=kw(u"nth"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid63, 16)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid63, 21)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid63, 26)), - ], - meta=i.Meta(mid63, 15)), - ), - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/count) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"count")), - i.Fn(args=[kw(u"coll")],name=kw(u"count"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid64, 12)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid64, 19)), - ], - meta=i.Meta(mid64, 11)), - )]), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/Cons) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"Cons")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"pixie.stdlib.Cons")), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"first")), - i.Const(kw(u"next")), - i.Const(kw(u"meta")), - ]), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/->Cons) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"->Cons")), - i.Fn(args=[kw(u"first"),kw(u"next"),kw(u"meta")],name=kw(u"->Cons"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=i.Meta(mid65, 10)), - i.Lookup(kw(u"first"), meta=nil), - i.Lookup(kw(u"next"), meta=nil), - i.Lookup(kw(u"meta"), meta=nil), - ], - meta=nil), - )]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-first"), meta=i.Meta(mid66, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), - i.Fn(args=[kw(u"this")],name=kw(u"-first_Cons"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid66, 12)), - i.Const(kw(u"first")), - ], - meta=nil), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-next"), meta=i.Meta(mid67, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), - i.Fn(args=[kw(u"this")],name=kw(u"-next_Cons"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid67, 11)), - i.Const(kw(u"next")), - ], - meta=nil), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid68, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), - i.Fn(args=[kw(u"this")],name=kw(u"-seq_Cons"), - body=i.Lookup(kw(u"this"), meta=i.Meta(mid68, 16)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-meta"), meta=i.Meta(mid69, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), - i.Fn(args=[kw(u"this")],name=kw(u"-meta_Cons"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid69, 11)), - i.Const(kw(u"meta")), - ], - meta=nil), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-with-meta"), meta=i.Meta(mid70, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Cons"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"new-meta")],name=kw(u"-with-meta_Cons"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid71, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid70, 16)), - i.Const(kw(u"first")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid70, 16)), - i.Const(kw(u"next")), - ], - meta=nil), - i.Lookup(kw(u"new-meta"), meta=i.Meta(mid71, 24)), - ], - meta=i.Meta(mid71, 5)), - ), - ], - meta=nil), - ], - meta=i.Meta(mid65, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/cons) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"cons")), - i.Fn(args=[kw(u"head"),kw(u"tail")],name=kw(u"cons"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Cons"), meta=i.Meta(mid72, 4)), - i.Lookup(kw(u"head"), meta=i.Meta(mid72, 11)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid72, 17)), - i.Lookup(kw(u"tail"), meta=i.Meta(mid72, 21)), - ], - meta=i.Meta(mid72, 16)), - i.Const(nil), - ], - meta=i.Meta(mid72, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/string-builder) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"string-builder")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"string-builder")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"string-builder"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid73, 8)), - ], - meta=i.Meta(mid73, 7)), - ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"sb")],name=kw(u"string-builder"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid74, 10)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid74, 15)), - ], - meta=i.Meta(mid74, 9)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"sb"),kw(u"x")],name=kw(u"string-builder"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid75, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"String"), meta=i.Meta(mid75, 19)), - i.Lookup(kw(u"x"), meta=i.Meta(mid75, 26)), - ], - meta=i.Meta(mid75, 8)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid76, 7)), - i.Lookup(kw(u"x"), meta=i.Meta(mid76, 30)), - ], - meta=i.Meta(mid76, 6)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-bulder"), meta=i.Meta(mid77, 7)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid77, 30)), - i.Lookup(kw(u"x"), meta=i.Meta(mid77, 35)), - ], - meta=i.Meta(mid77, 29)), - ], - meta=i.Meta(mid77, 6)), - meta=i.Meta(mid75, 4)), - ), - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/str) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"str")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(0)), - i.Fn(args=[kw(u"args")],name=kw(u"str"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid78, 4)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"map"), meta=i.Meta(mid79, 5)), - i.Lookup(kw(u"str"), meta=i.Meta(mid79, 9)), - ], - meta=i.Meta(mid79, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"string-builder"), meta=i.Meta(mid80, 4)), - i.Lookup(kw(u"args"), meta=i.Meta(mid81, 4)), - ], - meta=i.Meta(mid78, 3)), - )])]), - i.Invoke(args=[ -# (def pixie.stdlib/println) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"println")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(0)), - i.Fn(args=[kw(u"args")],name=kw(u"println"),closed_overs=[kw(u"add-fn"),kw(u"sb")], - body=i.Let(names=[kw(u"sb"),kw(u"add-fn")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-string-builder"), meta=i.Meta(mid82, 13)), - ], - meta=i.Meta(mid82, 12)), - i.Fn(args=[kw(u"x")],name=kw(u"fn_439"),closed_overs=[kw(u"sb")], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-add-to-string-builder"), meta=i.Meta(mid83, 19)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid83, 42)), - i.Lookup(kw(u"x"), meta=i.Meta(mid83, 45)), - ], - meta=i.Meta(mid83, 18)), - ), - ], - body=i.Do( - args=[ - i.Let(names=[kw(u"idx"),kw(u"sb")], - bindings=[ - i.Const(rt.wrap(0)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid84, 15)), - ], - body=i.Invoke( - args=[ - i.Fn(args=[kw(u"idx"),kw(u"sb")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"args"),kw(u"add-fn")], - body=i.Let(names=[kw(u"idx"),kw(u"sb")], - bindings=[ - i.Lookup(kw(u"idx"), meta=i.Meta(mid85, 12)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid84, 12)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid86, 12)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid86, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid86, 19)), - i.Lookup(kw(u"args"), meta=i.Meta(mid86, 25)), - ], - meta=i.Meta(mid86, 18)), - ], - meta=i.Meta(mid86, 11)), - then=i.TailCall( - args=[ - i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid87, 17)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid87, 21)), - ], - meta=i.Meta(mid87, 16)), - i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid88, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid88, 27)), - i.Lookup(kw(u"args"), meta=i.Meta(mid88, 32)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid88, 37)), - ], - meta=i.Meta(mid88, 26)), - i.Lookup(kw(u"add-fn"), meta=i.Meta(mid88, 42)), - ], - meta=i.Meta(mid88, 20)), - i.Invoke( - args=[ - i.Lookup(kw(u"add-fn"), meta=i.Meta(mid89, 21)), - i.Const(rt.wrap(u" ")), - ], - meta=i.Meta(mid89, 20)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid90, 18)), - ], - meta=i.Meta(mid88, 16)), - ], - meta=nil), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-blocking-println"), meta=i.Meta(mid91, 10)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-finish-string-builder"), meta=i.Meta(mid91, 29)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid91, 52)), - ], - meta=i.Meta(mid91, 28)), - ], - meta=i.Meta(mid91, 9)), - meta=i.Meta(mid86, 7)), - meta=nil), - ), - i.Lookup(kw(u"idx"), meta=i.Meta(mid85, 12)), - i.Lookup(kw(u"sb"), meta=i.Meta(mid84, 12)), - ], - meta=nil), - meta=i.Meta(mid85, 5)), - i.Const(nil), - ], - meta=nil), - meta=i.Meta(mid82, 3)), - )])]), - i.Invoke(args=[ -# (def pixie.stdlib/instance?) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"instance?")), - i.Fn(args=[kw(u"t"),kw(u"x")],name=kw(u"instance?"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid92, 8)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid92, 20)), - i.Lookup(kw(u"t"), meta=i.Meta(mid92, 29)), - ], - meta=i.Meta(mid92, 7)), - then=i.Let(names=[kw(u"ts")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid93, 15)), - i.Lookup(kw(u"t"), meta=i.Meta(mid93, 19)), - ], - meta=i.Meta(mid93, 14)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid94, 12)), - i.Lookup(kw(u"ts"), meta=i.Meta(mid94, 16)), - ], - meta=i.Meta(mid94, 11)), - then=i.Const(nil), - els=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid95, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid95, 28)), - i.Lookup(kw(u"ts"), meta=i.Meta(mid95, 34)), - ], - meta=i.Meta(mid95, 27)), - i.Lookup(kw(u"x"), meta=i.Meta(mid95, 38)), - ], - meta=i.Meta(mid95, 15)), - then=i.Const(true), - els=i.TailCall( - args=[ - i.Lookup(kw(u"instance?"), meta=i.Meta(mid96, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid96, 25)), - i.Lookup(kw(u"ts"), meta=i.Meta(mid96, 30)), - ], - meta=i.Meta(mid96, 24)), - i.Lookup(kw(u"x"), meta=i.Meta(mid96, 34)), - ], - meta=i.Meta(mid96, 13)), - meta=i.Meta(mid95, 11)), - meta=i.Meta(mid94, 7)), - meta=i.Meta(mid93, 5)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-instance?"), meta=i.Meta(mid97, 6)), - i.Lookup(kw(u"t"), meta=i.Meta(mid97, 17)), - i.Lookup(kw(u"x"), meta=i.Meta(mid97, 19)), - ], - meta=i.Meta(mid97, 5)), - meta=i.Meta(mid92, 3)), - )]), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/Reduced) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"Reduced")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"pixie.stdlib.Reduced")), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"x")), - ]), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/->Reduced) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"->Reduced")), - i.Fn(args=[kw(u"x")],name=kw(u"->Reduced"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid98, 10)), - i.Lookup(kw(u"x"), meta=nil), - ], - meta=nil), - )]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=i.Meta(mid99, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=nil), - i.Fn(args=[kw(u"this")],name=kw(u"-deref_Reduced"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid99, 12)), - i.Const(kw(u"x")), - ], - meta=nil), - ), - ], - meta=nil), - ], - meta=i.Meta(mid98, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/reduced) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"reduced")), - i.Fn(args=[kw(u"x")],name=kw(u"reduced"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Reduced"), meta=i.Meta(mid100, 4)), - i.Lookup(kw(u"x"), meta=i.Meta(mid100, 14)), - ], - meta=i.Meta(mid100, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/reduced?) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"reduced?")), - i.Fn(args=[kw(u"x")],name=kw(u"reduced?"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"instance?"), meta=i.Meta(mid101, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Reduced"), meta=i.Meta(mid101, 14)), - i.Lookup(kw(u"x"), meta=i.Meta(mid101, 22)), - ], - meta=i.Meta(mid101, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/satisfies?) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"satisfies?")), - i.Fn(args=[kw(u"p"),kw(u"x")],name=kw(u"satisfies?"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid102, 8)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"ISeqable"), meta=i.Meta(mid102, 20)), - i.Lookup(kw(u"p"), meta=i.Meta(mid102, 29)), - ], - meta=i.Meta(mid102, 7)), - then=i.Let(names=[kw(u"ps")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid103, 15)), - i.Lookup(kw(u"p"), meta=i.Meta(mid103, 19)), - ], - meta=i.Meta(mid103, 14)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid104, 12)), - i.Lookup(kw(u"ps"), meta=i.Meta(mid104, 16)), - ], - meta=i.Meta(mid104, 11)), - then=i.Const(true), - els=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"not"), meta=i.Meta(mid105, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid105, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid105, 34)), - i.Lookup(kw(u"ps"), meta=i.Meta(mid105, 40)), - ], - meta=i.Meta(mid105, 33)), - i.Lookup(kw(u"x"), meta=i.Meta(mid105, 44)), - ], - meta=i.Meta(mid105, 20)), - ], - meta=i.Meta(mid105, 15)), - then=i.Const(nil), - els=i.TailCall( - args=[ - i.Lookup(kw(u"satisfies?"), meta=i.Meta(mid106, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid106, 26)), - i.Lookup(kw(u"ps"), meta=i.Meta(mid106, 31)), - ], - meta=i.Meta(mid106, 25)), - i.Lookup(kw(u"x"), meta=i.Meta(mid106, 35)), - ], - meta=i.Meta(mid106, 13)), - meta=i.Meta(mid105, 11)), - meta=i.Meta(mid104, 7)), - meta=i.Meta(mid103, 5)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-satisfies?"), meta=i.Meta(mid107, 6)), - i.Lookup(kw(u"p"), meta=i.Meta(mid107, 18)), - i.Lookup(kw(u"x"), meta=i.Meta(mid107, 20)), - ], - meta=i.Meta(mid107, 5)), - meta=i.Meta(mid102, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/transduce) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"transduce")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"transduce")), - i.Const(rt.wrap(3)), i.Fn(args=[kw(u"xform"),kw(u"rf"),kw(u"coll")],name=kw(u"transduce"), - body=i.Let(names=[kw(u"f"),kw(u"result")], - bindings=[ - i.Invoke( - args=[ - i.Lookup(kw(u"xform"), meta=i.Meta(mid108, 13)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid108, 19)), - ], - meta=i.Meta(mid108, 12)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid109, 18)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid109, 26)), - i.Lookup(kw(u"f"), meta=i.Meta(mid109, 31)), - i.Invoke( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid109, 34)), - ], - meta=i.Meta(mid109, 33)), - ], - meta=i.Meta(mid109, 17)), - ], - body=i.TailCall( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid110, 7)), - i.Lookup(kw(u"result"), meta=i.Meta(mid110, 9)), - ], - meta=i.Meta(mid110, 6)), - meta=i.Meta(mid108, 4)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"f"),kw(u"coll")],name=kw(u"transduce"), - body=i.Let(names=[kw(u"result")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid111, 18)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid111, 26)), - i.Lookup(kw(u"f"), meta=i.Meta(mid111, 31)), - i.Invoke( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid111, 34)), - ], - meta=i.Meta(mid111, 33)), - ], - meta=i.Meta(mid111, 17)), - ], - body=i.TailCall( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid112, 7)), - i.Lookup(kw(u"result"), meta=i.Meta(mid112, 9)), - ], - meta=i.Meta(mid112, 6)), - meta=i.Meta(mid111, 4)), - ), - i.Const(rt.wrap(4)), i.Fn(args=[kw(u"xform"),kw(u"rf"),kw(u"init"),kw(u"coll")],name=kw(u"transduce"), - body=i.Let(names=[kw(u"f"),kw(u"result")], - bindings=[ - i.Invoke( - args=[ - i.Lookup(kw(u"xform"), meta=i.Meta(mid113, 13)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid113, 19)), - ], - meta=i.Meta(mid113, 12)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid114, 18)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid114, 26)), - i.Lookup(kw(u"f"), meta=i.Meta(mid114, 31)), - i.Lookup(kw(u"init"), meta=i.Meta(mid114, 33)), - ], - meta=i.Meta(mid114, 17)), - ], - body=i.TailCall( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid115, 7)), - i.Lookup(kw(u"result"), meta=i.Meta(mid115, 9)), - ], - meta=i.Meta(mid115, 6)), - meta=i.Meta(mid113, 4)), - ), - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/reduce) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"reduce")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"reduce")), - i.Const(rt.wrap(3)), i.Fn(args=[kw(u"rf"),kw(u"init"),kw(u"col")],name=kw(u"reduce"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid116, 5)), - i.Lookup(kw(u"col"), meta=i.Meta(mid116, 13)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid116, 17)), - i.Lookup(kw(u"init"), meta=i.Meta(mid116, 20)), - ], - meta=i.Meta(mid116, 4)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"rf"),kw(u"col")],name=kw(u"reduce"), - body=i.TailCall( - args=[ - i.Lookup(kw(u"reduce"), meta=i.Meta(mid117, 5)), - i.Lookup(kw(u"rf"), meta=i.Meta(mid117, 12)), - i.Invoke( - args=[ - i.Lookup(kw(u"rf"), meta=i.Meta(mid117, 16)), - ], - meta=i.Meta(mid117, 15)), - i.Lookup(kw(u"col"), meta=i.Meta(mid117, 20)), - ], - meta=i.Meta(mid117, 4)), - ), - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/into) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"into")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"into")), - i.Const(rt.wrap(3)), i.Fn(args=[kw(u"to"),kw(u"xform"),kw(u"from")],name=kw(u"into"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid118, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid118, 20)), - i.Lookup(kw(u"to"), meta=i.Meta(mid118, 33)), - ], - meta=i.Meta(mid118, 8)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid119, 7)), - i.Lookup(kw(u"xform"), meta=i.Meta(mid119, 17)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid119, 23)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid119, 30)), - i.Lookup(kw(u"to"), meta=i.Meta(mid119, 40)), - ], - meta=i.Meta(mid119, 29)), - i.Lookup(kw(u"from"), meta=i.Meta(mid119, 44)), - ], - meta=i.Meta(mid119, 6)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transduce"), meta=i.Meta(mid120, 7)), - i.Lookup(kw(u"xform"), meta=i.Meta(mid120, 17)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid120, 23)), - i.Lookup(kw(u"to"), meta=i.Meta(mid120, 28)), - i.Lookup(kw(u"from"), meta=i.Meta(mid120, 31)), - ], - meta=i.Meta(mid120, 6)), - meta=i.Meta(mid118, 4)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"to"),kw(u"from")],name=kw(u"into"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"satisfies?"), meta=i.Meta(mid121, 9)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"IToTransient"), meta=i.Meta(mid121, 20)), - i.Lookup(kw(u"to"), meta=i.Meta(mid121, 33)), - ], - meta=i.Meta(mid121, 8)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"persistent!"), meta=i.Meta(mid122, 7)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid122, 20)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj!"), meta=i.Meta(mid122, 27)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"transient"), meta=i.Meta(mid122, 34)), - i.Lookup(kw(u"to"), meta=i.Meta(mid122, 44)), - ], - meta=i.Meta(mid122, 33)), - i.Lookup(kw(u"from"), meta=i.Meta(mid122, 48)), - ], - meta=i.Meta(mid122, 19)), - ], - meta=i.Meta(mid122, 6)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduce"), meta=i.Meta(mid123, 7)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid123, 14)), - i.Lookup(kw(u"to"), meta=i.Meta(mid123, 19)), - i.Lookup(kw(u"from"), meta=i.Meta(mid123, 22)), - ], - meta=i.Meta(mid123, 6)), - meta=i.Meta(mid121, 4)), - ), - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/map) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"map")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"map")), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"f")],name=kw(u"map"), - body=i.Fn(args=[kw(u"xf")],name=kw(u"fn_476"),closed_overs=[kw(u"f")], - body=i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"fn_480")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"fn_480"),closed_overs=[kw(u"xf")], - body=i.TailCall( - args=[ - i.Lookup(kw(u"xf"), meta=i.Meta(mid124, 13)), - ], - meta=i.Meta(mid124, 12)), - ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"result")],name=kw(u"fn_480"),closed_overs=[kw(u"xf")], - body=i.TailCall( - args=[ - i.Lookup(kw(u"xf"), meta=i.Meta(mid125, 19)), - i.Lookup(kw(u"result"), meta=i.Meta(mid125, 22)), - ], - meta=i.Meta(mid125, 18)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"result"),kw(u"item")],name=kw(u"fn_480"),closed_overs=[kw(u"xf"),kw(u"f")], - body=i.TailCall( - args=[ - i.Lookup(kw(u"xf"), meta=i.Meta(mid126, 24)), - i.Lookup(kw(u"result"), meta=i.Meta(mid126, 27)), - i.Invoke( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid126, 35)), - i.Lookup(kw(u"item"), meta=i.Meta(mid126, 37)), - ], - meta=i.Meta(mid126, 34)), - ], - meta=i.Meta(mid126, 23)), - ), - ]), - ), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"f"),kw(u"coll")],name=kw(u"map"),closed_overs=[kw(u"map")], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid127, 5)), - i.Fn(args=[],name=kw(u"fn_481"),closed_overs=[kw(u"map"),kw(u"f"),kw(u"coll")], - body=i.Let(names=[kw(u"s")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid128, 16)), - i.Lookup(kw(u"coll"), meta=i.Meta(mid128, 20)), - ], - meta=i.Meta(mid128, 15)), - ], - body=i.If( - test=i.Lookup(kw(u"s"), meta=i.Meta(mid129, 13)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid130, 12)), - i.Invoke( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid130, 18)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid130, 21)), - i.Lookup(kw(u"s"), meta=i.Meta(mid130, 27)), - ], - meta=i.Meta(mid130, 20)), - ], - meta=i.Meta(mid130, 17)), - i.Invoke( - args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid131, 18)), - i.Lookup(kw(u"f"), meta=i.Meta(mid131, 22)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid131, 25)), - i.Lookup(kw(u"s"), meta=i.Meta(mid131, 30)), - ], - meta=i.Meta(mid131, 24)), - ], - meta=i.Meta(mid131, 17)), - ], - meta=i.Meta(mid130, 11)), - els=i.Const(nil), - meta=i.Meta(mid129, 9)), - meta=i.Meta(mid128, 7)), - ), - ], - meta=i.Meta(mid127, 4)), - ), - i.Const(rt.wrap(-1)), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"variadic-fn")), i.Const(rt.wrap(1)), - i.Fn(args=[kw(u"f"),kw(u"colls")],name=kw(u"map"),closed_overs=[kw(u"step"),kw(u"map")], - body=i.Let(names=[kw(u"step")], - bindings=[ - i.Fn(args=[kw(u"cs")],name=kw(u"step"),closed_overs=[kw(u"step"),kw(u"map")], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid132, 18)), - i.Fn(args=[],name=kw(u"fn_483"),closed_overs=[kw(u"step"),kw(u"map"),kw(u"cs")], - body=i.Let(names=[kw(u"ss")], - bindings=[ - i.Invoke( - args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid133, 30)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid133, 34)), - i.Lookup(kw(u"cs"), meta=i.Meta(mid133, 38)), - ], - meta=i.Meta(mid133, 29)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"every?"), meta=i.Meta(mid134, 27)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"identity"), meta=i.Meta(mid134, 34)), - i.Lookup(kw(u"ss"), meta=i.Meta(mid134, 43)), - ], - meta=i.Meta(mid134, 26)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid135, 25)), - i.Invoke( - args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid135, 31)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"first"), meta=i.Meta(mid135, 35)), - i.Lookup(kw(u"ss"), meta=i.Meta(mid135, 41)), - ], - meta=i.Meta(mid135, 30)), - i.Invoke( - args=[ - i.Lookup(kw(u"step"), meta=i.Meta(mid135, 46)), - i.Invoke( - args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid135, 52)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"rest"), meta=i.Meta(mid135, 56)), - i.Lookup(kw(u"ss"), meta=i.Meta(mid135, 61)), - ], - meta=i.Meta(mid135, 51)), - ], - meta=i.Meta(mid135, 45)), - ], - meta=i.Meta(mid135, 24)), - els=i.Const(nil), - meta=i.Meta(mid134, 22)), - meta=i.Meta(mid133, 20)), - ), - ], - meta=i.Meta(mid132, 17)), - ), - ], - body=i.TailCall( - args=[ - i.Lookup(kw(u"map"), meta=i.Meta(mid136, 7)), - i.Fn(args=[kw(u"args")],name=kw(u"fn_485"),closed_overs=[kw(u"f")], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"apply"), meta=i.Meta(mid136, 23)), - i.Lookup(kw(u"f"), meta=i.Meta(mid136, 29)), - i.Lookup(kw(u"args"), meta=i.Meta(mid136, 31)), - ], - meta=i.Meta(mid136, 22)), - ), - i.Invoke( - args=[ - i.Lookup(kw(u"step"), meta=i.Meta(mid136, 39)), - i.Lookup(kw(u"colls"), meta=i.Meta(mid136, 44)), - ], - meta=i.Meta(mid136, 38)), - ], - meta=i.Meta(mid136, 6)), - meta=i.Meta(mid137, 4)), - )]) - ])]), - i.Const(nil), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib.range/Range) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib.range",u"Range")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"pixie.stdlib.range.Range")), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"start")), - i.Const(kw(u"stop")), - i.Const(kw(u"step")), - ]), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib.range/->Range) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib.range",u"->Range")), - i.Fn(args=[kw(u"start"),kw(u"stop"),kw(u"step")],name=kw(u"->Range"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=i.Meta(mid138, 10)), - i.Lookup(kw(u"start"), meta=nil), - i.Lookup(kw(u"stop"), meta=nil), - i.Lookup(kw(u"step"), meta=nil), - ], - meta=nil), - )]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid139, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"self"),kw(u"f"),kw(u"init")],name=kw(u"-reduce_Range"), - body=i.Let(names=[kw(u"i"),kw(u"acc")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Lookup(kw(u"init"), meta=i.Meta(mid140, 16)), - ], - body=i.TailCall( - args=[ - i.Fn(args=[kw(u"i"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"self"),kw(u"f")], - body=i.Let(names=[kw(u"i"),kw(u"acc")], - bindings=[ - i.Lookup(kw(u"i"), meta=i.Meta(mid141, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid140, 12)), - ], - body=i.If( - test=i.Let(names=[kw(u"r#__gensym_321")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid142, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid142, 20)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid142, 32)), - i.Lookup(kw(u"i"), meta=i.Meta(mid142, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid142, 31)), - els=i.Const(nil), - meta=i.Meta(mid142, 15)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_321"), meta=nil), - els=i.Let(names=[kw(u"r#__gensym_320")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid143, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid143, 20)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid143, 32)), - i.Lookup(kw(u"i"), meta=i.Meta(mid143, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid143, 31)), - els=i.Const(nil), - meta=i.Meta(mid143, 15)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid144, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid144, 15)), - meta=nil), - meta=nil), - meta=nil), - meta=i.Meta(mid142, 11)), - then=i.Let(names=[kw(u"acc")], - bindings=[ - i.Invoke( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid145, 20)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid145, 22)), - i.Lookup(kw(u"i"), meta=i.Meta(mid145, 26)), - ], - meta=i.Meta(mid145, 19)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid146, 16)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid146, 25)), - ], - meta=i.Meta(mid146, 15)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), - i.Lookup(kw(u"acc"), meta=i.Meta(mid147, 14)), - ], - meta=i.Meta(mid147, 13)), - els=i.TailCall( - args=[ - i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid148, 21)), - i.Lookup(kw(u"i"), meta=i.Meta(mid148, 23)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid139, 13)), - i.Const(kw(u"step")), - ], - meta=nil), - ], - meta=i.Meta(mid148, 20)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid148, 31)), - ], - meta=nil), - meta=i.Meta(mid146, 11)), - meta=i.Meta(mid145, 9)), - els=i.Lookup(kw(u"acc"), meta=i.Meta(mid149, 9)), - meta=i.Meta(mid142, 7)), - meta=nil), - ), - i.Lookup(kw(u"i"), meta=i.Meta(mid141, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid140, 12)), - ], - meta=nil), - meta=i.Meta(mid141, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid150, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"self")],name=kw(u"-count_Range"), - body=i.If( - test=i.Let(names=[kw(u"r#__gensym_321")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid151, 19)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid151, 18)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid151, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid151, 33)), - els=i.Const(nil), - meta=i.Meta(mid151, 13)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_321"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_321"), meta=nil), - els=i.Let(names=[kw(u"r#__gensym_320")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid152, 19)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid152, 18)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid152, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid152, 33)), - els=i.Const(nil), - meta=i.Meta(mid152, 13)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid153, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid153, 13)), - meta=nil), - meta=nil), - meta=nil), - meta=i.Meta(mid151, 9)), - then=i.Const(rt.wrap(0)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"abs"), meta=i.Meta(mid154, 8)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"quot"), meta=i.Meta(mid154, 13)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid154, 19)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid154, 18)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid150, 12)), - i.Const(kw(u"step")), - ], - meta=nil), - ], - meta=i.Meta(mid154, 12)), - ], - meta=i.Meta(mid154, 7)), - meta=i.Meta(mid151, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid155, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"self"),kw(u"idx")],name=kw(u"-nth_Range"), - body=i.Do( - args=[ - i.If( - test=i.Let(names=[kw(u"r#__gensym_320")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid156, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), - i.Const(kw(u"stop")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid156, 15)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"neg?"), meta=i.Meta(mid156, 33)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid156, 38)), - ], - meta=i.Meta(mid156, 32)), - meta=nil), - meta=i.Meta(mid156, 11)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid157, 8)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), - i.Const(rt.wrap(u"Index out of Range")), - ]), - ], - meta=i.Meta(mid157, 7)), - els=i.Const(nil), - meta=i.Meta(mid156, 5)), - i.Let(names=[kw(u"cmp"),kw(u"val")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid158, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid158, 19)), - then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid158, 34)), - els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid158, 36)), - meta=i.Meta(mid158, 15)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid159, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid159, 25)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid159, 27)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), - i.Const(kw(u"step")), - ], - meta=nil), - ], - meta=i.Meta(mid159, 24)), - ], - meta=i.Meta(mid159, 15)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.Lookup(kw(u"cmp"), meta=i.Meta(mid160, 12)), - i.Lookup(kw(u"val"), meta=i.Meta(mid160, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid155, 10)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid160, 11)), - then=i.Lookup(kw(u"val"), meta=i.Meta(mid161, 9)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid162, 10)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/OutOfRangeException")), - i.Const(rt.wrap(u"Index out of Range")), - ]), - ], - meta=i.Meta(mid162, 9)), - meta=i.Meta(mid160, 7)), - meta=i.Meta(mid158, 5)), - ], - meta=nil), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid163, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"self"),kw(u"idx"),kw(u"not-found")],name=kw(u"-nth-not-found_Range"), - body=i.Let(names=[kw(u"cmp"),kw(u"val")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid164, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid164, 19)), - then=i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid164, 34)), - els=i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid164, 36)), - meta=i.Meta(mid164, 15)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid165, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"*"), meta=i.Meta(mid165, 25)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid165, 27)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), - i.Const(kw(u"step")), - ], - meta=nil), - ], - meta=i.Meta(mid165, 24)), - ], - meta=i.Meta(mid165, 15)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.Lookup(kw(u"cmp"), meta=i.Meta(mid166, 12)), - i.Lookup(kw(u"val"), meta=i.Meta(mid166, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid163, 20)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid166, 11)), - then=i.Lookup(kw(u"val"), meta=i.Meta(mid167, 9)), - els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid168, 8)), - meta=i.Meta(mid166, 7)), - meta=i.Meta(mid164, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-seq"), meta=i.Meta(mid169, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"self")],name=kw(u"-seq_Range"), - body=i.If( - test=i.Let(names=[kw(u"r#__gensym_320")], - bindings=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid170, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid170, 20)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid170, 32)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid170, 31)), - els=i.Const(nil), - meta=i.Meta(mid170, 15)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - els=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid171, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"step")), - ], - meta=nil), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid171, 20)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid171, 32)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"stop")), - ], - meta=nil), - ], - meta=i.Meta(mid171, 31)), - els=i.Const(nil), - meta=i.Meta(mid171, 15)), - meta=nil), - meta=i.Meta(mid170, 11)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"cons"), meta=i.Meta(mid172, 8)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"lazy-seq*"), meta=i.Meta(mid172, 20)), - i.Fn(args=[],name=kw(u"fn_504"),closed_overs=[kw(u"self")], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid172, 32)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid172, 39)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"start")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"step")), - ], - meta=nil), - ], - meta=i.Meta(mid172, 38)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"stop")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid169, 10)), - i.Const(kw(u"step")), - ], - meta=nil), - ], - meta=i.Meta(mid172, 31)), - ), - ], - meta=i.Meta(mid172, 19)), - ], - meta=i.Meta(mid172, 7)), - els=i.Const(nil), - meta=i.Meta(mid170, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid173, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-str_Range"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-str"), meta=i.Meta(mid174, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid174, 12)), - i.Lookup(kw(u"this"), meta=i.Meta(mid174, 16)), - ], - meta=i.Meta(mid174, 11)), - i.Lookup(kw(u"sbf"), meta=i.Meta(mid174, 22)), - ], - meta=i.Meta(mid174, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid175, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"sbf")],name=kw(u"-repr_Range"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-repr"), meta=i.Meta(mid176, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"seq"), meta=i.Meta(mid176, 13)), - i.Lookup(kw(u"this"), meta=i.Meta(mid176, 17)), - ], - meta=i.Meta(mid176, 12)), - i.Lookup(kw(u"sbf"), meta=i.Meta(mid176, 23)), - ], - meta=i.Meta(mid176, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-eq"), meta=i.Meta(mid177, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"Range"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"sb")],name=kw(u"-eq_Range"), - body=i.Const(nil), - ), - ], - meta=nil), - ], - meta=i.Meta(mid138, 1)), - i.Invoke(args=[ -# (def pixie.stdlib.range/MAX-NUMBER) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib.range",u"MAX-NUMBER")), - i.Const(rt.wrap(4294967295))]), - i.Const(nil), - i.Invoke(args=[ -# (def pixie.stdlib/range) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"range")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"range")), - i.Const(rt.wrap(0)), i.Fn(args=[],name=kw(u"range"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid178, 8)), - i.Const(rt.wrap(0)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"MAX-NUMBER"), meta=i.Meta(mid178, 37)), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid178, 7)), - ), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"stop")],name=kw(u"range"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid179, 12)), - i.Const(rt.wrap(0)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid179, 41)), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid179, 11)), - ), - i.Const(rt.wrap(3)), i.Fn(args=[kw(u"start"),kw(u"stop"),kw(u"step")],name=kw(u"range"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid180, 23)), - i.Lookup(kw(u"start"), meta=i.Meta(mid180, 50)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid180, 56)), - i.Lookup(kw(u"step"), meta=i.Meta(mid180, 61)), - ], - meta=i.Meta(mid180, 22)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"start"),kw(u"stop")],name=kw(u"range"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib.range", u"->Range"), meta=i.Meta(mid181, 18)), - i.Lookup(kw(u"start"), meta=i.Meta(mid181, 45)), - i.Lookup(kw(u"stop"), meta=i.Meta(mid181, 51)), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid181, 17)), - ), - ])]), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/Node) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"Node")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"pixie.stdlib.Node")), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"edit")), - i.Const(kw(u"array")), - ]), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/->Node) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"->Node")), - i.Fn(args=[kw(u"edit"),kw(u"array")],name=kw(u"->Node"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=i.Meta(mid182, 10)), - i.Lookup(kw(u"edit"), meta=nil), - i.Lookup(kw(u"array"), meta=nil), - ], - meta=nil), - )]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid183, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Node"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_Node"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid184, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid184, 16)), - i.Lookup(kw(u"name"), meta=i.Meta(mid184, 21)), - ], - meta=i.Meta(mid184, 5)), - ), - ], - meta=nil), - ], - meta=i.Meta(mid182, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/new-node) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"new-node")), - i.Invoke([i.Const(code.intern_var(u"pixie.stdlib", u"multi-arity-fn")), i.Const(rt.wrap(u"new-node")), - i.Const(rt.wrap(1)), i.Fn(args=[kw(u"edit")],name=kw(u"new-node"), - body=i.TailCall( - args=[ - i.Lookup(kw(u"new-node"), meta=i.Meta(mid185, 5)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid185, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid185, 20)), - i.Const(rt.wrap(32)), - ], - meta=i.Meta(mid185, 19)), - ], - meta=i.Meta(mid185, 4)), - ), - i.Const(rt.wrap(2)), i.Fn(args=[kw(u"edit"),kw(u"array")],name=kw(u"new-node"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid186, 5)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid186, 12)), - i.Lookup(kw(u"array"), meta=i.Meta(mid186, 17)), - ], - meta=i.Meta(mid186, 4)), - ), - ])]), - i.Invoke(args=[ -# (def pixie.stdlib/EMPTY-NODE) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY-NODE")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid187, 18)), - i.Const(nil), - ], - meta=i.Meta(mid187, 17))]), - i.Invoke(args=[ -# (def pixie.stdlib/tailoff) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"tailoff")), - i.Fn(args=[kw(u"this")],name=kw(u"tailoff"), - body=i.Let(names=[kw(u"cnt")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid189, 20)), - i.Const(kw(u"cnt")), - ], - meta=i.Meta(mid189, 13)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid190, 10)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid190, 12)), - i.Const(rt.wrap(32)), - ], - meta=i.Meta(mid190, 9)), - then=i.Const(rt.wrap(0)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid191, 8)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid191, 24)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid191, 41)), - i.Lookup(kw(u"cnt"), meta=i.Meta(mid191, 45)), - ], - meta=i.Meta(mid191, 40)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid191, 23)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid191, 7)), - meta=i.Meta(mid190, 5)), - meta=i.Meta(mid189, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/array-for) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"array-for")), - i.Fn(args=[kw(u"this"),kw(u"i")],name=kw(u"array-for"), - body=i.If( - test=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid192, 13)), - i.Const(rt.wrap(0)), - i.Lookup(kw(u"i"), meta=i.Meta(mid192, 18)), - ], - meta=i.Meta(mid192, 12)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid192, 22)), - i.Lookup(kw(u"i"), meta=i.Meta(mid192, 24)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid192, 33)), - i.Const(kw(u"cnt")), - ], - meta=i.Meta(mid192, 26)), - ], - meta=i.Meta(mid192, 21)), - els=i.Const(nil), - meta=i.Meta(mid192, 7)), - then=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">="), meta=i.Meta(mid193, 10)), - i.Lookup(kw(u"i"), meta=i.Meta(mid193, 13)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid193, 16)), - i.Lookup(kw(u"this"), meta=i.Meta(mid193, 24)), - ], - meta=i.Meta(mid193, 15)), - ], - meta=i.Meta(mid193, 9)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid194, 15)), - i.Const(kw(u"tail")), - ], - meta=i.Meta(mid194, 7)), - els=i.Let(names=[kw(u"node"),kw(u"level")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid195, 27)), - i.Const(kw(u"root")), - ], - meta=i.Meta(mid195, 19)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid196, 29)), - i.Const(kw(u"shift")), - ], - meta=i.Meta(mid196, 20)), - ], - body=i.TailCall( - args=[ - i.Fn(args=[kw(u"node"),kw(u"level")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"i")], - body=i.Let(names=[kw(u"node"),kw(u"level")], - bindings=[ - i.Lookup(kw(u"node"), meta=i.Meta(mid195, 14)), - i.Lookup(kw(u"level"), meta=i.Meta(mid196, 14)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid197, 14)), - i.Lookup(kw(u"level"), meta=i.Meta(mid197, 16)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid197, 13)), - then=i.TailCall( - args=[ - i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid198, 19)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"node"), meta=i.Meta(mid198, 33)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid198, 24)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid199, 25)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid199, 34)), - i.Lookup(kw(u"i"), meta=i.Meta(mid199, 50)), - i.Lookup(kw(u"level"), meta=i.Meta(mid199, 52)), - ], - meta=i.Meta(mid199, 33)), - i.Const(rt.wrap(31)), - ], - meta=i.Meta(mid199, 24)), - ], - meta=i.Meta(mid198, 18)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid200, 19)), - i.Lookup(kw(u"level"), meta=i.Meta(mid200, 21)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid200, 18)), - ], - meta=nil), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"node"), meta=i.Meta(mid201, 20)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid201, 11)), - meta=i.Meta(mid197, 9)), - meta=nil), - ), - i.Lookup(kw(u"node"), meta=i.Meta(mid195, 14)), - i.Lookup(kw(u"level"), meta=i.Meta(mid196, 14)), - ], - meta=nil), - meta=i.Meta(mid195, 7)), - meta=i.Meta(mid193, 5)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid202, 6)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/IndexOutOfRangeException")), - i.Const(rt.wrap(u"Index out of range")), - ]), - ], - meta=i.Meta(mid202, 5)), - meta=i.Meta(mid192, 3)), - )]), - i.Do( - args=[ - i.Invoke(args=[ -# (def pixie.stdlib/PersistentVector) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"PersistentVector")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"create-type"), meta=nil), - i.Const(kw(u"pixie.stdlib.PersistentVector")), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"cnt")), - i.Const(kw(u"shift")), - i.Const(kw(u"root")), - i.Const(kw(u"tail")), - i.Const(kw(u"meta")), - ]), - ], - meta=nil)]), - i.Invoke(args=[ -# (def pixie.stdlib/->PersistentVector) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"->PersistentVector")), - i.Fn(args=[kw(u"cnt"),kw(u"shift"),kw(u"root"),kw(u"tail"),kw(u"meta")],name=kw(u"->PersistentVector"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=i.Meta(mid203, 10)), - i.Lookup(kw(u"cnt"), meta=nil), - i.Lookup(kw(u"shift"), meta=nil), - i.Lookup(kw(u"root"), meta=nil), - i.Lookup(kw(u"tail"), meta=nil), - i.Lookup(kw(u"meta"), meta=nil), - ], - meta=nil), - )]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid204, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"name")],name=kw(u"-get-field_PersistentVector"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=i.Meta(mid205, 6)), - i.Lookup(kw(u"this"), meta=i.Meta(mid205, 16)), - i.Lookup(kw(u"name"), meta=i.Meta(mid205, 21)), - ], - meta=i.Meta(mid205, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid206, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"val")],name=kw(u"-conj_PersistentVector"), - body=i.Do( - args=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid207, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"cnt")), - ], - meta=nil), - i.Const(rt.wrap(4294967295)), - ], - meta=i.Meta(mid207, 13)), - then=i.Const(nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=nil), - i.Const(rt.wrap(u"Assert failed: ")), - i.Const(rt.wrap(u"Vector too large")), - ], - meta=nil), - ]), - ], - meta=nil), - meta=i.Meta(mid207, 5)), - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid208, 10)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid208, 13)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"cnt")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid208, 20)), - i.Lookup(kw(u"this"), meta=i.Meta(mid208, 28)), - ], - meta=i.Meta(mid208, 19)), - ], - meta=i.Meta(mid208, 12)), - i.Const(rt.wrap(32)), - ], - meta=i.Meta(mid208, 9)), - then=i.Let(names=[kw(u"new-tail")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-append"), meta=i.Meta(mid209, 23)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"tail")), - ], - meta=nil), - i.Lookup(kw(u"val"), meta=i.Meta(mid209, 41)), - ], - meta=i.Meta(mid209, 22)), - ], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid210, 10)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid210, 30)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid210, 29)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"root")), - ], - meta=nil), - i.Lookup(kw(u"new-tail"), meta=i.Meta(mid210, 50)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"meta")), - ], - meta=nil), - ], - meta=i.Meta(mid210, 9)), - meta=i.Meta(mid209, 7)), - els=i.Let(names=[kw(u"tail-node")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid211, 24)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"root")), - ], - meta=nil), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid211, 31)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"tail")), - ], - meta=nil), - ], - meta=i.Meta(mid211, 23)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid212, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid212, 17)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"cnt")), - ], - meta=nil), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid212, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-left"), meta=i.Meta(mid212, 41)), - i.Const(rt.wrap(1)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"shift")), - ], - meta=nil), - ], - meta=i.Meta(mid212, 40)), - ], - meta=i.Meta(mid212, 13)), - then=i.Let(names=[kw(u"new-root"),kw(u"new-root-arr")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid213, 27)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"root")), - ], - meta=nil), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid213, 36)), - ], - meta=i.Meta(mid213, 26)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid214, 39)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid214, 30)), - ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid215, 14)), - i.Lookup(kw(u"new-root-arr"), meta=i.Meta(mid215, 19)), - i.Const(rt.wrap(0)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"root")), - ], - meta=nil), - ], - meta=i.Meta(mid215, 13)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid216, 14)), - i.Lookup(kw(u"new-root-arr"), meta=i.Meta(mid216, 19)), - i.Const(rt.wrap(1)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid216, 35)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"root")), - ], - meta=nil), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid216, 44)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid216, 64)), - ], - meta=i.Meta(mid216, 34)), - ], - meta=i.Meta(mid216, 13)), - i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid217, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid217, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid217, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid218, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid218, 33)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid219, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid220, 34)), - i.Lookup(kw(u"val"), meta=i.Meta(mid220, 40)), - ], - meta=i.Meta(mid220, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"meta")), - ], - meta=nil), - ], - meta=i.Meta(mid217, 13)), - ], - meta=nil), - meta=i.Meta(mid213, 11)), - els=i.Let(names=[kw(u"new-root")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"push-tail"), meta=i.Meta(mid221, 27)), - i.Lookup(kw(u"this"), meta=i.Meta(mid221, 37)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"root")), - ], - meta=nil), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid221, 53)), - ], - meta=i.Meta(mid221, 26)), - ], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid222, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid222, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid222, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid223, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid224, 34)), - i.Lookup(kw(u"val"), meta=i.Meta(mid224, 40)), - ], - meta=i.Meta(mid224, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid206, 11)), - i.Const(kw(u"meta")), - ], - meta=nil), - ], - meta=i.Meta(mid222, 13)), - meta=i.Meta(mid221, 11)), - meta=i.Meta(mid212, 9)), - meta=i.Meta(mid211, 7)), - meta=i.Meta(mid208, 5)), - ], - meta=nil), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth"), meta=i.Meta(mid225, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), - i.Fn(args=[kw(u"self"),kw(u"i")],name=kw(u"-nth_PersistentVector"), - body=i.If( - test=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid226, 15)), - i.Const(rt.wrap(0)), - i.Lookup(kw(u"i"), meta=i.Meta(mid226, 20)), - ], - meta=i.Meta(mid226, 14)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid227, 15)), - i.Lookup(kw(u"i"), meta=i.Meta(mid227, 17)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid225, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid227, 14)), - els=i.Const(nil), - meta=i.Meta(mid226, 9)), - then=i.Let(names=[kw(u"node")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-for"), meta=i.Meta(mid228, 19)), - i.Lookup(kw(u"self"), meta=i.Meta(mid228, 29)), - i.Lookup(kw(u"i"), meta=i.Meta(mid228, 34)), - ], - meta=i.Meta(mid228, 18)), - ], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid229, 10)), - i.Lookup(kw(u"node"), meta=i.Meta(mid229, 15)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid229, 21)), - i.Lookup(kw(u"i"), meta=i.Meta(mid229, 29)), - i.Const(rt.wrap(31)), - ], - meta=i.Meta(mid229, 20)), - ], - meta=i.Meta(mid229, 9)), - meta=i.Meta(mid228, 7)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=i.Meta(mid230, 8)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/IndexOutOfRange")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=i.Meta(mid231, 16)), - i.Const(rt.wrap(u"Index out of range, got ")), - i.Lookup(kw(u"i"), meta=i.Meta(mid231, 47)), - i.Const(rt.wrap(u" only have ")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid225, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid231, 15)), - ]), - ], - meta=i.Meta(mid230, 7)), - meta=i.Meta(mid226, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid232, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), - i.Fn(args=[kw(u"self"),kw(u"i"),kw(u"not-found")],name=kw(u"-nth-not-found_PersistentVector"), - body=i.If( - test=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<="), meta=i.Meta(mid233, 15)), - i.Const(rt.wrap(0)), - i.Lookup(kw(u"i"), meta=i.Meta(mid233, 20)), - ], - meta=i.Meta(mid233, 14)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid234, 15)), - i.Lookup(kw(u"i"), meta=i.Meta(mid234, 17)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"self"), meta=i.Meta(mid232, 20)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid234, 14)), - els=i.Const(nil), - meta=i.Meta(mid233, 9)), - then=i.Let(names=[kw(u"node")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-for"), meta=i.Meta(mid235, 19)), - i.Lookup(kw(u"self"), meta=i.Meta(mid235, 29)), - i.Lookup(kw(u"i"), meta=i.Meta(mid235, 34)), - ], - meta=i.Meta(mid235, 18)), - ], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid236, 10)), - i.Lookup(kw(u"node"), meta=i.Meta(mid236, 15)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid236, 21)), - i.Lookup(kw(u"i"), meta=i.Meta(mid236, 29)), - i.Const(rt.wrap(31)), - ], - meta=i.Meta(mid236, 20)), - ], - meta=i.Meta(mid236, 9)), - meta=i.Meta(mid235, 7)), - els=i.Lookup(kw(u"not-found"), meta=i.Meta(mid237, 7)), - meta=i.Meta(mid233, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get"), meta=i.Meta(mid238, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), - i.Fn(args=[kw(u"this"),kw(u"val")],name=kw(u"-get_PersistentVector"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-nth-not-found"), meta=i.Meta(mid239, 6)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"self"), meta=i.Meta(mid239, 21)), - i.Lookup(kw(u"val"), meta=i.Meta(mid239, 26)), - i.Const(nil), - ], - meta=i.Meta(mid239, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid240, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), - i.Fn(args=[kw(u"this")],name=kw(u"-count_PersistentVector"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid240, 12)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-pop"), meta=i.Meta(mid241, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"PersistentVector"), meta=nil), - i.Fn(args=[kw(u"this")],name=kw(u"-pop_PersistentVector"), - body=i.Do( - args=[ - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"!="), meta=i.Meta(mid242, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid242, 13)), - then=i.Const(nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"str"), meta=nil), - i.Const(rt.wrap(u"Assert failed: ")), - i.Const(rt.wrap(u"Can't pop an empty vector")), - ], - meta=nil), - ]), - ], - meta=nil), - meta=i.Meta(mid242, 5)), - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"=="), meta=i.Meta(mid243, 10)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid243, 9)), - then=i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY"), meta=i.Meta(mid244, 7)), - els=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid245, 12)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid245, 15)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"tailoff"), meta=i.Meta(mid245, 22)), - i.Lookup(kw(u"this"), meta=i.Meta(mid245, 30)), - ], - meta=i.Meta(mid245, 21)), - ], - meta=i.Meta(mid245, 14)), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid245, 11)), - then=i.Let(names=[kw(u"size"),kw(u"new-tail")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid246, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid246, 26)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"tail")), - ], - meta=nil), - ], - meta=i.Meta(mid246, 25)), - ], - meta=i.Meta(mid246, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-resize"), meta=i.Meta(mid247, 25)), - i.Lookup(kw(u"size"), meta=i.Meta(mid247, 38)), - ], - meta=i.Meta(mid247, 24)), - ], - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid248, 12)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid248, 32)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid248, 31)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"root")), - ], - meta=nil), - i.Lookup(kw(u"new-tail"), meta=i.Meta(mid249, 31)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"meta")), - ], - meta=nil), - ], - meta=i.Meta(mid248, 11)), - meta=i.Meta(mid246, 9)), - els=i.Let(names=[kw(u"new-tail"),kw(u"new-root")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-for"), meta=i.Meta(mid250, 25)), - i.Lookup(kw(u"this"), meta=i.Meta(mid250, 35)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid250, 41)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - i.Const(rt.wrap(2)), - ], - meta=i.Meta(mid250, 40)), - ], - meta=i.Meta(mid250, 24)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"pop-tail"), meta=i.Meta(mid251, 25)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"root")), - ], - meta=nil), - ], - meta=i.Meta(mid251, 24)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"nil?"), meta=i.Meta(mid252, 14)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid252, 19)), - ], - meta=i.Meta(mid252, 13)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersisentVector"), meta=i.Meta(mid253, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid253, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid253, 32)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid254, 32)), - i.Lookup(kw(u"new-tail"), meta=i.Meta(mid255, 32)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"meta")), - ], - meta=nil), - ], - meta=i.Meta(mid253, 13)), - els=i.If( - test=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid256, 19)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid256, 18)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"nil?"), meta=i.Meta(mid257, 19)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid257, 25)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid257, 39)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid257, 30)), - i.Const(rt.wrap(1)), - ], - meta=i.Meta(mid257, 24)), - ], - meta=i.Meta(mid257, 18)), - els=i.Const(nil), - meta=i.Meta(mid256, 13)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid258, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid258, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid258, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid259, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid259, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid260, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid260, 48)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid260, 39)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid260, 33)), - i.Lookup(kw(u"new-tail"), meta=i.Meta(mid261, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"meta")), - ], - meta=nil), - ], - meta=i.Meta(mid258, 13)), - els=i.If( - test=i.Const(kw(u"else")), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid262, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid262, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"cnt")), - ], - meta=nil), - ], - meta=i.Meta(mid262, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"shift")), - ], - meta=nil), - i.Lookup(kw(u"new-root"), meta=i.Meta(mid263, 33)), - i.Lookup(kw(u"new-tail"), meta=i.Meta(mid264, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"get-field"), meta=nil), - i.Lookup(kw(u"this"), meta=i.Meta(mid241, 10)), - i.Const(kw(u"meta")), - ], - meta=nil), - ], - meta=i.Meta(mid262, 13)), - els=i.Const(nil), - meta=nil), - meta=nil), - meta=i.Meta(mid265, 11)), - meta=i.Meta(mid250, 9)), - meta=i.Meta(mid245, 7)), - meta=i.Meta(mid243, 5)), - ], - meta=nil), - ), - ], - meta=nil), - ], - meta=i.Meta(mid203, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/push-tail) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"push-tail")), - i.Fn(args=[kw(u"this"),kw(u"level"),kw(u"parent"),kw(u"tail-node")],name=kw(u"push-tail"), - body=i.Let(names=[kw(u"subidx"),kw(u"ret-array"),kw(u"node-to-insert")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid266, 17)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid266, 26)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid266, 43)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid266, 54)), - i.Const(kw(u"cnt")), - ], - meta=i.Meta(mid266, 47)), - ], - meta=i.Meta(mid266, 42)), - i.Lookup(kw(u"level"), meta=i.Meta(mid266, 61)), - ], - meta=i.Meta(mid266, 25)), - i.Const(rt.wrap(31)), - ], - meta=i.Meta(mid266, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-clone"), meta=i.Meta(mid267, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"parent"), meta=i.Meta(mid267, 41)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid267, 32)), - ], - meta=i.Meta(mid267, 19)), - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid268, 29)), - i.Lookup(kw(u"level"), meta=i.Meta(mid268, 31)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid268, 28)), - then=i.Lookup(kw(u"tail-node"), meta=i.Meta(mid269, 26)), - els=i.Let(names=[kw(u"child")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid270, 39)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"parent"), meta=i.Meta(mid270, 53)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid270, 44)), - i.Lookup(kw(u"subidx"), meta=i.Meta(mid270, 61)), - ], - meta=i.Meta(mid270, 38)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid271, 33)), - i.Lookup(kw(u"child"), meta=i.Meta(mid271, 35)), - i.Const(nil), - ], - meta=i.Meta(mid271, 32)), - then=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-path"), meta=i.Meta(mid272, 31)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid272, 56)), - i.Const(kw(u"root")), - ], - meta=i.Meta(mid272, 48)), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid272, 40)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid273, 41)), - i.Lookup(kw(u"level"), meta=i.Meta(mid273, 43)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid273, 40)), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid274, 40)), - ], - meta=i.Meta(mid272, 30)), - els=i.Invoke( - args=[ - i.Lookup(kw(u"push-tail"), meta=i.Meta(mid275, 31)), - i.Lookup(kw(u"this"), meta=i.Meta(mid275, 41)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid276, 42)), - i.Lookup(kw(u"level"), meta=i.Meta(mid276, 44)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid276, 41)), - i.Lookup(kw(u"child"), meta=i.Meta(mid277, 41)), - i.Lookup(kw(u"tail-node"), meta=i.Meta(mid278, 41)), - ], - meta=i.Meta(mid275, 30)), - meta=i.Meta(mid271, 28)), - meta=i.Meta(mid270, 26)), - meta=i.Meta(mid268, 24)), - ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid279, 6)), - i.Lookup(kw(u"ret-array"), meta=i.Meta(mid279, 11)), - i.Lookup(kw(u"subidx"), meta=i.Meta(mid279, 21)), - i.Lookup(kw(u"node-to-insert"), meta=i.Meta(mid279, 28)), - ], - meta=i.Meta(mid279, 5)), - i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid280, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"parent"), meta=i.Meta(mid280, 21)), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid280, 13)), - i.Lookup(kw(u"ret-array"), meta=i.Meta(mid280, 29)), - ], - meta=i.Meta(mid280, 5)), - ], - meta=nil), - meta=i.Meta(mid266, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/pop-tail) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"pop-tail")), - i.Fn(args=[kw(u"this"),kw(u"level"),kw(u"node")],name=kw(u"pop-tail"), - body=i.Let(names=[kw(u"sub-idx")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-and"), meta=i.Meta(mid281, 18)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"bit-shift-right"), meta=i.Meta(mid281, 27)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"dec"), meta=i.Meta(mid281, 44)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Const(kw(u"cnt")), - ], - meta=i.Meta(mid281, 48)), - ], - meta=i.Meta(mid281, 43)), - i.Lookup(kw(u"level"), meta=i.Meta(mid281, 57)), - ], - meta=i.Meta(mid281, 26)), - i.Const(rt.wrap(31)), - ], - meta=i.Meta(mid281, 17)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u">"), meta=i.Meta(mid282, 8)), - i.Lookup(kw(u"level"), meta=i.Meta(mid282, 10)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid282, 7)), - then=i.Let(names=[kw(u"new-child")], - bindings=[ - i.Invoke( - args=[ - i.Lookup(kw(u"pop-tail"), meta=i.Meta(mid283, 24)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid283, 34)), - i.Lookup(kw(u"level"), meta=i.Meta(mid283, 36)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid283, 33)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid284, 34)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"node"), meta=i.Meta(mid284, 48)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid284, 39)), - i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid284, 54)), - ], - meta=i.Meta(mid284, 33)), - ], - meta=i.Meta(mid283, 23)), - ], - body=i.If( - test=i.Let(names=[kw(u"r#__gensym_320")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"nil?"), meta=i.Meta(mid285, 18)), - i.Lookup(kw(u"new-child"), meta=i.Meta(mid285, 23)), - ], - meta=i.Meta(mid285, 17)), - ], - body=i.If( - test=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - then=i.Lookup(kw(u"r#__gensym_320"), meta=nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid286, 18)), - i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid286, 20)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid286, 17)), - meta=nil), - meta=i.Meta(mid285, 13)), - then=i.Const(nil), - els=i.Let(names=[kw(u"root"),kw(u"ret")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid287, 30)), - i.Const(kw(u"root")), - ], - meta=i.Meta(mid287, 22)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid288, 22)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"root"), meta=i.Meta(mid288, 37)), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid288, 29)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"node"), meta=i.Meta(mid289, 38)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid289, 29)), - ], - meta=i.Meta(mid288, 21)), - ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid290, 14)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"ret"), meta=i.Meta(mid290, 28)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid290, 19)), - i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid290, 33)), - i.Lookup(kw(u"new-child"), meta=i.Meta(mid290, 41)), - ], - meta=i.Meta(mid290, 13)), - i.Lookup(kw(u"ret"), meta=i.Meta(mid291, 13)), - ], - meta=nil), - meta=i.Meta(mid287, 11)), - meta=i.Meta(mid285, 9)), - meta=i.Meta(mid283, 7)), - els=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid292, 8)), - i.Lookup(kw(u"sub-idx"), meta=i.Meta(mid292, 10)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid292, 7)), - then=i.Const(nil), - els=i.If( - test=i.Const(kw(u"else")), - then=i.Let(names=[kw(u"root"),kw(u"ret")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"this"), meta=i.Meta(mid293, 26)), - i.Const(kw(u"root")), - ], - meta=i.Meta(mid293, 18)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->Node"), meta=i.Meta(mid294, 18)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"root"), meta=i.Meta(mid294, 33)), - i.Const(kw(u"edit")), - ], - meta=i.Meta(mid294, 25)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aclone"), meta=i.Meta(mid295, 26)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"node"), meta=i.Meta(mid295, 42)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid295, 33)), - ], - meta=i.Meta(mid295, 25)), - ], - meta=i.Meta(mid294, 17)), - ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid296, 10)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"ret"), meta=i.Meta(mid296, 24)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid296, 15)), - i.Const(nil), - ], - meta=i.Meta(mid296, 9)), - i.Lookup(kw(u"ret"), meta=i.Meta(mid297, 9)), - ], - meta=nil), - meta=i.Meta(mid293, 7)), - els=i.Const(nil), - meta=nil), - meta=nil), - meta=i.Meta(mid298, 5)), - meta=i.Meta(mid281, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/new-path) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"new-path")), - i.Fn(args=[kw(u"edit"),kw(u"level"),kw(u"node")],name=kw(u"new-path"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid299, 8)), - i.Lookup(kw(u"level"), meta=i.Meta(mid299, 10)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid299, 7)), - then=i.Lookup(kw(u"node"), meta=i.Meta(mid300, 5)), - els=i.Let(names=[kw(u"nnode")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"new-node"), meta=i.Meta(mid301, 18)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid301, 27)), - ], - meta=i.Meta(mid301, 17)), - ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid302, 8)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"nnode"), meta=i.Meta(mid302, 22)), - i.Const(kw(u"array")), - ], - meta=i.Meta(mid302, 13)), - i.Const(rt.wrap(0)), - i.Invoke( - args=[ - i.Lookup(kw(u"new-path"), meta=i.Meta(mid302, 32)), - i.Lookup(kw(u"edit"), meta=i.Meta(mid302, 41)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-"), meta=i.Meta(mid302, 47)), - i.Lookup(kw(u"level"), meta=i.Meta(mid302, 49)), - i.Const(rt.wrap(5)), - ], - meta=i.Meta(mid302, 46)), - i.Lookup(kw(u"node"), meta=i.Meta(mid302, 58)), - ], - meta=i.Meta(mid302, 31)), - ], - meta=i.Meta(mid302, 7)), - i.Lookup(kw(u"nnode"), meta=i.Meta(mid303, 7)), - ], - meta=nil), - meta=i.Meta(mid301, 5)), - meta=i.Meta(mid299, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/EMPTY) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"EMPTY")), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid304, 13)), - i.Const(rt.wrap(0)), - i.Const(rt.wrap(5)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid304, 36)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array"), meta=i.Meta(mid304, 48)), - i.Const(rt.wrap(0)), - ], - meta=i.Meta(mid304, 47)), - i.Const(nil), - ], - meta=i.Meta(mid304, 12))]), - i.Invoke(args=[ -# (def pixie.stdlib/vector-from-array) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"vector-from-array")), - i.Fn(args=[kw(u"arr")],name=kw(u"vector-from-array"), - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid305, 8)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid305, 11)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid305, 17)), - ], - meta=i.Meta(mid305, 10)), - i.Const(rt.wrap(32)), - ], - meta=i.Meta(mid305, 7)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"->PersistentVector"), meta=i.Meta(mid306, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid306, 26)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid306, 32)), - ], - meta=i.Meta(mid306, 25)), - i.Const(rt.wrap(5)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"EMPTY-NODE"), meta=i.Meta(mid306, 39)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid306, 50)), - i.Const(nil), - ], - meta=i.Meta(mid306, 5)), - els=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid307, 6)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), - i.Lookup(kw(u"arr"), meta=i.Meta(mid307, 14)), - ], - meta=i.Meta(mid307, 5)), - meta=i.Meta(mid305, 3)), - )]), - i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-reduce"), meta=i.Meta(mid308, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid309, 14)), - i.Fn(args=[kw(u"this"),kw(u"f"),kw(u"init")],name=kw(u"fn_564"), - body=i.Let(names=[kw(u"idx"),kw(u"acc")], - bindings=[ - i.Const(rt.wrap(0)), - i.Lookup(kw(u"init"), meta=i.Meta(mid310, 16)), - ], - body=i.TailCall( - args=[ - i.Fn(args=[kw(u"idx"),kw(u"acc")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"this"),kw(u"f")], - body=i.Let(names=[kw(u"idx"),kw(u"acc")], - bindings=[ - i.Lookup(kw(u"idx"), meta=i.Meta(mid311, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid310, 12)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"reduced?"), meta=i.Meta(mid312, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid312, 21)), - ], - meta=i.Meta(mid312, 11)), - then=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-deref"), meta=nil), - i.Lookup(kw(u"acc"), meta=i.Meta(mid313, 10)), - ], - meta=i.Meta(mid313, 9)), - els=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid314, 14)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid314, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid314, 21)), - i.Lookup(kw(u"this"), meta=i.Meta(mid314, 27)), - ], - meta=i.Meta(mid314, 20)), - ], - meta=i.Meta(mid314, 13)), - then=i.TailCall( - args=[ - i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid315, 19)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid315, 23)), - ], - meta=i.Meta(mid315, 18)), - i.Invoke( - args=[ - i.Lookup(kw(u"f"), meta=i.Meta(mid316, 19)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid316, 21)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid316, 26)), - i.Lookup(kw(u"this"), meta=i.Meta(mid316, 31)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid316, 36)), - ], - meta=i.Meta(mid316, 25)), - ], - meta=i.Meta(mid316, 18)), - ], - meta=nil), - els=i.Lookup(kw(u"acc"), meta=i.Meta(mid317, 11)), - meta=i.Meta(mid314, 9)), - meta=i.Meta(mid312, 7)), - meta=nil), - ), - i.Lookup(kw(u"idx"), meta=i.Meta(mid311, 12)), - i.Lookup(kw(u"acc"), meta=i.Meta(mid310, 12)), - ], - meta=nil), - meta=i.Meta(mid311, 5)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-count"), meta=i.Meta(mid318, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid309, 14)), - i.Fn(args=[kw(u"arr")],name=kw(u"fn_568"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"-get-field"), meta=i.Meta(mid188, 37)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid319, 21)), - i.Const(kw(u"count")), - ], - meta=i.Meta(mid319, 12)), - ), - ], - meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"extend"), meta=nil), - i.VDeref(code.intern_var(u"pixie.stdlib", u"-conj"), meta=i.Meta(mid320, 4)), - i.VDeref(code.intern_var(u"pixie.stdlib", u"Array"), meta=i.Meta(mid309, 14)), - i.Fn(args=[kw(u"arr"),kw(u"itm")],name=kw(u"fn_560"), - body=i.TailCall( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"conj"), meta=i.Meta(mid321, 6)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"vector-from-array"), meta=i.Meta(mid321, 12)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid321, 30)), - ], - meta=i.Meta(mid321, 11)), - i.Lookup(kw(u"itm"), meta=i.Meta(mid321, 35)), - ], - meta=i.Meta(mid321, 5)), - ), - ], - meta=nil), - ], - meta=i.Meta(mid309, 1)), - i.Invoke(args=[ -# (def pixie.stdlib/array-copy) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"array-copy")), - i.Fn(args=[kw(u"from"),kw(u"from-idx"),kw(u"to"),kw(u"to-idx"),kw(u"size")],name=kw(u"array-copy"), - body=i.Let(names=[kw(u"idx")], - bindings=[ - i.Const(rt.wrap(0)), - ], - body=i.TailCall( - args=[ - i.Fn(args=[kw(u"idx")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"size"),kw(u"from-idx"),kw(u"to"),kw(u"to-idx"),kw(u"from")], - body=i.Let(names=[kw(u"idx")], - bindings=[ - i.Lookup(kw(u"idx"), meta=i.Meta(mid322, 10)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"<"), meta=i.Meta(mid323, 12)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid323, 14)), - i.Lookup(kw(u"size"), meta=i.Meta(mid323, 18)), - ], - meta=i.Meta(mid323, 11)), - then=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid324, 12)), - i.Lookup(kw(u"to"), meta=i.Meta(mid324, 17)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid324, 21)), - i.Lookup(kw(u"to-idx"), meta=i.Meta(mid324, 23)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid324, 30)), - ], - meta=i.Meta(mid324, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aget"), meta=i.Meta(mid324, 36)), - i.Lookup(kw(u"from"), meta=i.Meta(mid324, 41)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"+"), meta=i.Meta(mid324, 47)), - i.Lookup(kw(u"from-idx"), meta=i.Meta(mid324, 49)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid324, 58)), - ], - meta=i.Meta(mid324, 46)), - ], - meta=i.Meta(mid324, 35)), - ], - meta=i.Meta(mid324, 11)), - i.TailCall( - args=[ - i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid325, 19)), - i.Lookup(kw(u"idx"), meta=i.Meta(mid325, 23)), - ], - meta=i.Meta(mid325, 18)), - ], - meta=nil), - ], - meta=i.Meta(mid324, 7)), - els=i.Const(nil), - meta=i.Meta(mid323, 5)), - meta=nil), - ), - i.Lookup(kw(u"idx"), meta=i.Meta(mid322, 10)), - ], - meta=nil), - meta=i.Meta(mid322, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/array-append) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"array-append")), - i.Fn(args=[kw(u"arr"),kw(u"val")],name=kw(u"array-append"), - body=i.Let(names=[kw(u"new-array")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid326, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=i.Meta(mid326, 32)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid326, 37)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid326, 43)), - ], - meta=i.Meta(mid326, 36)), - ], - meta=i.Meta(mid326, 31)), - ], - meta=i.Meta(mid326, 19)), - ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid327, 6)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid327, 17)), - i.Const(rt.wrap(0)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid327, 23)), - i.Const(rt.wrap(0)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid327, 36)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid327, 42)), - ], - meta=i.Meta(mid327, 35)), - ], - meta=i.Meta(mid327, 5)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"aset"), meta=i.Meta(mid328, 6)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid328, 11)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid328, 22)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid328, 28)), - ], - meta=i.Meta(mid328, 21)), - i.Lookup(kw(u"val"), meta=i.Meta(mid328, 33)), - ], - meta=i.Meta(mid328, 5)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid329, 5)), - ], - meta=nil), - meta=i.Meta(mid326, 3)), - )]), - i.Invoke(args=[ -# (def pixie.stdlib/array-clone) - i.Const(code.intern_var(u"pixie.stdlib", u"set-var-root!")), - i.Const(code.intern_var(u"pixie.stdlib",u"array-clone")), - i.Fn(args=[kw(u"arr")],name=kw(u"array-clone"), - body=i.Let(names=[kw(u"new-array")], - bindings=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"make-array"), meta=i.Meta(mid330, 20)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid330, 32)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid330, 38)), - ], - meta=i.Meta(mid330, 31)), - ], - meta=i.Meta(mid330, 19)), - ], - body=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"array-copy"), meta=i.Meta(mid331, 6)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid331, 17)), - i.Const(rt.wrap(0)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid331, 23)), - i.Const(rt.wrap(0)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"count"), meta=i.Meta(mid331, 36)), - i.Lookup(kw(u"arr"), meta=i.Meta(mid331, 42)), - ], - meta=i.Meta(mid331, 35)), - ], - meta=i.Meta(mid331, 5)), - i.Lookup(kw(u"new-array"), meta=i.Meta(mid332, 5)), - ], - meta=nil), - meta=i.Meta(mid330, 3)), - )]), - i.Let(names=[kw(u"MAX"),kw(u"v")], - bindings=[ - i.Const(rt.wrap(1024)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"into"), meta=i.Meta(mid333, 10)), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), ]), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"range"), meta=i.Meta(mid333, 19)), - i.Lookup(kw(u"MAX"), meta=i.Meta(mid333, 25)), - ], - meta=i.Meta(mid333, 18)), - ], - meta=i.Meta(mid333, 9)), - ], - body=i.Let(names=[kw(u"max#__gensym_319")], - bindings=[ - i.Lookup(kw(u"MAX"), meta=i.Meta(mid334, 15)), - ], - body=i.Let(names=[kw(u"x")], - bindings=[ - i.Const(rt.wrap(0)), - ], - body=i.Invoke( - args=[ - i.Fn(args=[kw(u"x")],name=kw(u"pixie.compiler/__loop__fn__"),closed_overs=[kw(u"v"),kw(u"max#__gensym_319")], - body=i.Let(names=[kw(u"x")], - bindings=[ - i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), - ], - body=i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=nil), - i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), - i.Lookup(kw(u"max#__gensym_319"), meta=nil), - ], - meta=nil), - then=i.Const(nil), - els=i.Do( - args=[ - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"println"), meta=i.Meta(mid335, 6)), - i.Lookup(kw(u"x"), meta=i.Meta(mid335, 14)), - ], - meta=i.Meta(mid335, 5)), - i.If( - test=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"="), meta=i.Meta(mid336, 14)), - i.Lookup(kw(u"x"), meta=i.Meta(mid336, 16)), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"nth"), meta=i.Meta(mid336, 19)), - i.Lookup(kw(u"v"), meta=i.Meta(mid336, 23)), - i.Lookup(kw(u"x"), meta=i.Meta(mid336, 25)), - ], - meta=i.Meta(mid336, 18)), - ], - meta=i.Meta(mid336, 13)), - then=i.Const(nil), - els=i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"throw"), meta=nil), - i.Invoke(args=[ - i.Const(code.intern_var(u"pixie.stdlib", u"array")), i.Const(kw(u"pixie.stdlib/AssertionException")), - i.Const(rt.wrap(u"Assert failed")), - ]), - ], - meta=nil), - meta=i.Meta(mid336, 5)), - i.TailCall( - args=[ - i.Lookup(kw(u"pixie.compiler/__loop__fn__"), meta=nil), - i.Invoke( - args=[ - i.VDeref(code.intern_var(u"pixie.stdlib", u"inc"), meta=nil), - i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), - ], - meta=nil), - ], - meta=nil), - ], - meta=nil), - meta=nil), - meta=nil), - ), - i.Lookup(kw(u"x"), meta=i.Meta(mid334, 13)), - ], - meta=nil), - meta=nil), - meta=i.Meta(mid334, 3)), - meta=i.Meta(mid337, 1)), - i.Const(nil), - ], -meta=i.Meta(mid338, 1)) \ No newline at end of file diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 65c728ce..37335933 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -177,6 +177,18 @@ (apply = y rest) false))) +(defn not + [x] + (if x false true)) + +(defn not= + ([& args] + (not (-apply = args)))) + +(defn nil? + [x] + (identical? x nil)) + (defn conj ([] []) ([coll] coll) @@ -184,6 +196,9 @@ ([coll item & more] (-apply conj (conj x y) more))) +(defn pop + ([] []) + ([coll] (-pop coll))) (defn nth {:doc "Returns the element at the idx. If the index is not found it will return an error. @@ -433,6 +448,8 @@ ;; PersistentVector +(in-ns :pixie.stdlib.persistent-vector) + (deftype Node [edit array] IMessageObject (-get-field [this name] @@ -527,20 +544,20 @@ IPop (-pop [this] - (assert (!= cnt) "Can't pop an empty vector") + (assert (not= cnt 0) "Can't pop an empty vector") - (if (== cnt 1) + (if (= cnt 1) EMPTY (if (> (- cnt (tailoff this)) 1) (let [size (dec (count tail)) - new-tail (array-resize size)] + new-tail (array-resize tail size)] (->PersistentVector (dec cnt) shift root new-tail meta)) (let [new-tail (array-for this (- cnt 2)) - new-root (pop-tail shift root)] + new-root (pop-tail this shift root)] (cond (nil? new-root) (->PersisentVector (dec cnt) @@ -561,7 +578,30 @@ shift new-root new-tail - meta))))))) + meta)))))) + + IAssociative + (-assoc [this k v] + (assert (int? k) "Vectors expect ints as keys") + (if (and (>= idx 0) + (< idx cnt)) + (if (>= idx (tail-off this)) + (let [new-tail (array-clone tail)] + (aset new-tail (bit-and idx 0x01f) val) + (->PersistentVector cnt shift root new-tail meta)) + (->PersistentVector cnt shift (do-assoc shift root idx val) tail meta)) + (if (= idx cnt) + (-conj this val) + (throw [:pixie.stdlib/IndexOutOfRange + "Can only assoc to the end or the contents of a vector"]))))) + +(defn do-assoc [lvl node idx val] + (let [new-array (array-clone (.-array node)) + ret (if (= lvl 0) + (aset new-array (bit-and idx 0x01f) val) + (let [sub-idx (bit-and (bit-shift-right idx lvl) 0x01f)] + (aset new-array sub-idx (do-assoc (- lvl 5) (aget (.-array node) idx val)))))] + (->Node (.-edit node) new-array))) (defn push-tail [this level parent tail-node] @@ -582,10 +622,11 @@ (->Node (.-edit parent) ret-array))) (defn pop-tail [this level node] - (let [sub-idx (bit-and (bit-shift-right (dec (.-cnt)) level) 0x01F)] + (let [sub-idx (bit-and (bit-shift-right (dec (.-cnt this)) level) 0x01F)] (cond (> level 5) - (let [new-child (pop-tail (- level 5) + (let [new-child (pop-tail this + (- level 5) (aget (.-array node) sub-idx))] (if (or (nil? new-child) (= sub-idx 0)) @@ -602,8 +643,8 @@ :else (let [root (.-root this) ret (->Node (.-edit root) - (aclone (.-array node)))] - (aset (.-array ret) nil) + (array-clone (.-array node)))] + (aset (.-array ret) sub-idx nil) ret)))) (defn new-path [edit level node] @@ -621,6 +662,8 @@ (->PersistentVector (count arr) 5 EMPTY-NODE arr nil) (into [] arr))) +(in-ns :pixie.stdlib) + ;; Extend Array (extend-type Array @@ -660,37 +703,17 @@ (array-copy arr 0 new-array 0 (count arr)) new-array)) -;;; - -(let [MAX 1024 - v (into [] (range MAX))] - (dotimes [x MAX] - (println x) - (assert (= x (nth v x))))) - -#_(let [arr1 (make-array 32) - arr2 (make-array 32)] - (dotimes [x 3000] - (array-copy arr1 0 arr2 0 (count arr1)))) - -#_(dotimes [x 10000] - (dotimes [y 5])) - -(comment - (println 42) - - #_(into [] (range 4)) - - - (println ( (fn [x] - (assert (< x 0xFFFFFFFF) "Vector too large") +(defn array-resize [arr size] + (let [new-array (make-array size)] + (array-copy arr 0 new-array 0 size) + new-array)) - (if true - 11 - 2)) 0)) +;;; - (println ((fn [] - (if true nil (println 100)) - 11))) - (println 44)) +(println (count (reduce + (fn [acc _] + (pop acc)) + + (into [] (range 1024)) + (range 1024)))) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 1395c146..9d138875 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -1,6 +1,8 @@ (ns pixie.compiler (:require [pixie.io :as io] - [pixie.string :as string])) + [pixie.string :as string] + [pixie.time :refer [time]] + [pixie.pxic-writer :as pxic-writer])) (def macro-overrides { @@ -296,10 +298,6 @@ (resolve-in (the-ns (:ns *env*)) sym)) (catch :pixie.stdlib/AssertionException ex nil))] - (println sym resolved [ (if resolved - (namespace resolved))] - (:ns *env*) - (contains? macro-overrides resolved)) (cond (and (symbol? sym) (string/starts-with? (name sym) ".-")) @@ -375,7 +373,6 @@ (resolve-in namesp x) (catch :pixie.stdlib/AssertionException ex nil))] - (println x (namespace x) (name x)) (cond (namespace x) {:op :var @@ -480,6 +477,80 @@ :children ast)) +(defn convert-defs [ast] + (walk (fn [{:keys [op name env val form] :as ast}] + (if (= op :def) + {:op :invoke + :form form + :env env + :children '[:args] + :args [{:op :var + :ns "pixie.stdlib" + :name "set-var-root!"} + {:op :var + :ns (:ns env) + :name name + :form name} + val]} + + ast)) + identity + :children + ast)) + +(defn pass-for [ast op-for f] + (walk (fn [{:keys [op] :as ast}] + (if (= op op-for) + (f ast) + ast)) + identity + :children + ast)) + +(defn convert-fns [ast] + (pass-for ast :fn + (fn [{:keys [name arities form env]}] + (if (= (count arities) 1) + (convert-fn-body (first arities)) + {:op :invoke + :form form + :env env + :children '[:args] + :args (concat [{:op :var + :ns "pixie.stdlib" + :name "multi-arity-fn" + :env env + :form 'multi-arity-fn} + {:op :const + :form name + :env env}] + (mapcat + (fn [{:keys [args variadic?] :as body}] + [{:op :const + :form (if variadic? + -1 + (count args)) + :env env} + (convert-fn-body body)]) + arities))})))) + +(defn convert-fn-body [{:keys [variadic? args body form env] :as ast}] + (if variadic? + {:op :invoke + :form form + :env env + :children '[:args] + :args [{:op :var + :ns "pixie.stdlib" + :name "variadic-fn" + :form 'variadic-fn + :env :env} + {:op :const + :form (dec (count args)) + :env env} + (convert-fn-body (dissoc ast :variadic?))]} + (assoc ast :op :fn-body))) + (defn write! [{:keys [code] :as state} val] (swap! code conj! val) state) @@ -771,7 +842,19 @@ "code_ast=" (string-builder @code))) -(let [form (read-string (str "(do " (pixie.io/slurp "pixie/bootstrap.pxi") ")")) - str (finish-context (to-rpython (writer-context) 0 (collect-closed-overs (clean-do (analyze form)))))] - (print str) - (io/spit "./bootstrap.py" str)) +(println "Reading") +(let [form (time (read-string (str "(do " (pixie.io/slurp "pixie/bootstrap.pxi") ")"))) + _ (println "Compiling") + ast (time (analyze form)) + _ (println "Passes") + ast (time (convert-fns (convert-defs (collect-closed-overs (clean-do ast))))) + _ (println "To String") + ;str (time (finish-context (to-rpython (writer-context) 0 ast))) + os (-> "/tmp/bootstrap.pxic" + io/open-write + io/buffered-output-stream)] + (binding [pxic-writer/*cache* (pxic-writer/writer-cache os)] + (time (pxic-writer/write-object os ast))) + #_(print str) + (dispose! os) + (println "done")) diff --git a/pixie/io.pxi b/pixie/io.pxi index 9929018e..720af8f9 100644 --- a/pixie/io.pxi +++ b/pixie/io.pxi @@ -13,7 +13,7 @@ (uv/defuvfsfn fs_close [file] :result) -(def DEFAULT-BUFFER-SIZE 1024) +(def DEFAULT-BUFFER-SIZE (* 32 1024)) (deftype FileStream [fp offset uvbuf] IInputStream @@ -62,7 +62,7 @@ (defn read-line "Read one line from input-stream for each invocation. - nil when all lines have been read" +kl nil when all lines have been read" [input-stream] (let [line-feed (into #{} (map int [\newline \return])) buf (buffer 1)] @@ -100,7 +100,7 @@ (-dispose! [this] (fclose fp))) -(deftype BufferedOutputStream [downstream idx buffer] +(deftype BufferedOutputStream [downstream idx buffer disposed?] IByteOutputStream (write-byte [this val] (pixie.ffi/pack! buffer idx CUInt8 val) @@ -111,6 +111,8 @@ (set-field! this :idx 0))) IDisposable (-dispose! [this] + (assert (not disposed?) "Can't dispose twice!") + (set-field! this :disposed? true) (set-buffer-count! buffer idx) (write downstream buffer)) IFlushableStream @@ -136,7 +138,7 @@ ([downstream] (buffered-output-stream downstream DEFAULT-BUFFER-SIZE)) ([downstream size] - (->BufferedOutputStream downstream 0 (buffer size)))) + (->BufferedOutputStream downstream 0 (buffer size) false))) (defn buffered-input-stream ([upstream] @@ -164,24 +166,33 @@ (defn spit "Writes the content to output. Output must be a file or an IOutputStream." - [output content] - (cond - (string? output) - (transduce (map identity) - (-> output - open-write - buffered-output-stream - utf8/utf8-output-stream-rf) - (str content)) - - (satisfies? IOutputStream output) - (transduce (map identity) - (-> output - buffered-output-stream - utf8/utf8-output-stream-rf) - (str content)) - - :else (throw "Expected a string or IOutputStream"))) + ([output content] + (spit output content true)) + ([output content dispose?] + (cond + (string? output) + (transduce (map identity) + (-> output + open-write + buffered-output-stream + (utf8/utf8-output-stream-rf dispose?)) + (str content)) + + (satisfies? IOutputStream output) + (transduce (map identity) + (-> output + buffered-output-stream + (utf8/utf8-output-stream-rf dispose?)) + (str content)) + + (satisfies? IByteOutputStream output) + (transduce (map identity) + (-> output + (utf8/utf8-output-stream-rf dispose?)) + (str content)) + + :else (throw [:pixie.stdlib/InvalidInputException + "Expected a string or IOutputStream"])))) (defn slurp "Reads in the contents of input. Input must be a filename or an IInputStream" diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi new file mode 100644 index 00000000..4d57a19b --- /dev/null +++ b/pixie/pxic-writer.pxi @@ -0,0 +1,217 @@ +(ns pixie.pxic-writer + (:require [pixie.streams :refer [write-byte]] + [pixie.streams.utf8 :refer [utf8-output-stream-rf]] + [pixie.io :refer [spit]])) + +(def MAX_INT32 (bit-shift-left 1 31)) + +(defmacro defenum [nms]) + + + + +(defmacro defbytecodes [bytecodes] + `(do ~@(map + (fn [idx k] + `(def ~(symbol (name k)) ~idx)) + (range) + bytecodes))) + +(defbytecodes + [:CACHED-OBJECT + :INT + :FLOAT + :INT-STRING + :STRING + :AST + :TRUE + :FALSE + :NIL + :VAR + :KEYWORD + :SYMBOL + :NEW-CACHED-OBJECT]) + + +(defbytecodes + [:DO + :INVOKE + :VAR + :CONST + :FN + :LOOKUP + :IF]) + +(def *cache* nil) +(set-dynamic! (var *cache*)) + + +(defprotocol IWriterCache + (write-cached-obj [this val wfn])) + +(deftype NullWriterCache [] + IWriterCache + (write-cached-obj [this val wfn] + (apply wfn val))) + +(deftype WriterCache [os cache] + IWriterCache + (write-cached-obj [this val wfn] + (println "Cache" (cache val) val) + (if-let [idx (cache val)] + (do (write-tag os CACHED-OBJECT) + (write-int-raw os idx) + (println "Wrote cached")) + (let [idx (count cache)] + (println "writing uncached") + (set-field! this :cache (assoc cache val idx)) + (write-tag os NEW-CACHED-OBJECT) + (apply wfn val))))) + + +(defn writer-cache [os] + (->WriterCache os {})) + +(defn write-raw-string [os str] + (write-int-raw os (count str)) + (println "spit " str) + (spit os str false)) + +(defn write-int-raw [os i] + (if (<= 0 i MAX_INT32) + (do (write-byte os (bit-and i 0xFF)) + (write-byte os (bit-and (bit-shift-right i 8) 0xFF)) + (write-byte os (bit-and (bit-shift-right i 16) 0xFF)) + (write-byte os (bit-and (bit-shift-right i 24) 0xFF))) + (throw [:pixie.pxic-writer/OversizedInt + "Collection sizes are limited to 32 bits in pxic files"]))) + +(defn write-int [os i] + (if (<= 0 i MAX_INT32) + (do (write-byte os INT) + (write-int-raw os i)) + (do (write-byte os INT-STRING) + (write-raw-string os (str i))))) + +(defn write-tag [os tag] + (write-byte os tag)) + +(defprotocol IPxicObject + (-write-object [this os])) + +(defmulti write-ast (fn [os ast] + (:op ast))) + +(defmethod write-ast :do + [os {:keys [statements ret]}] + (write-tag os AST) + (write-tag os DO) + (write-int-raw os (inc (count statements))) + (doseq [statement statements] + (write-object os statement)) + (write-object os ret)) + +(defmethod write-ast :invoke + [os {:keys [args]}] + (write-tag os AST) + (write-tag os INVOKE) + (write-int-raw os (count args)) + (doseq [arg args] + (write-object os arg))) + +(defmethod write-ast :var + [os {:keys [ns name]}] + (write-cached-obj *cache* + [ns name] + (fn [ns name] + (write-tag os AST) + (write-tag os VAR) + (write-raw-string os (str ns)) + (write-raw-string os (str name))))) + +(defmethod write-ast :const + [os {:keys [form]}] + (write-cached-obj *cache* + [form] + (fn [form] + (write-tag os CONST) + (write-object os form)))) + +(defmethod write-ast :fn-body + [os {:keys [name args closed-overs body]}] + (write-tag os AST) + (write-tag os FN) + (write-raw-string os (str name)) + (write-int-raw os (count args)) + (doseq [arg args] + (write-object os (keyword (str arg)))) + (write-int-raw os (count closed-overs)) + (doseq [co closed-overs] + (write-object os (keyword (str co)))) + (write-object os body)) + +(defmethod write-ast :binding + [os {:keys [name]}] + (write-tag os AST) + (write-tag os LOOKUP) + (write-object os (keyword (pixie.stdlib/name name)))) + +(defmethod write-ast :if + [os {:keys [test then else]}] + (write-tag os AST) + (write-tag os IF) + (write-object os test) + (write-object os then) + (write-object os else)) + +(extend-protocol IPxicObject + IMap + (-write-object [this os] + (println (keys this)) + (write-ast os this)) + + String + (-write-object [this os] + (write-cached-obj *cache* + [this] + (fn [this] + (write-tag os STRING) + (write-raw-string os this)))) + + Keyword + (-write-object [this os] + (write-cached-obj *cache* + [this] + (fn [this] + (write-tag os KEYWORD) + (if (namespace this) + (write-raw-string os (str (namespace this) "/" (name this))) + (write-raw-string os (str this)))))) + + Symbol + (-write-object [this os] + (write-cached-obj *cache* + [this] + (fn [this] + (write-tag os SYMBOL) + (if (namespace this) + (write-raw-string os (str (namespace this) "/" (name this))) + (write-raw-string os (str this)))))) + + Integer + (-write-object [this os] + (write-int os this)) + + Bool + (-write-object [this os] + (if this + (write-tag os TRUE) + (write-tag os FALSE))) + + Nil + (-write-object [this os] + (write-tag os NIL))) + + +(defn write-object [os ast] + (-write-object ast os)) diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index 92395f63..5648c19d 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -305,7 +305,7 @@ (comment (extend -reduce Array indexed-reduce)) (extend -reduce Buffer indexed-reduce) -(extend -reduce String indexed-reduce) +#_(extend -reduce String indexed-reduce) (extend -str Bool (fn [x] diff --git a/pixie/streams/utf8.pxi b/pixie/streams/utf8.pxi index bc9b4044..9d49eb73 100644 --- a/pixie/streams/utf8.pxi +++ b/pixie/streams/utf8.pxi @@ -27,7 +27,6 @@ (-dispose! [this] (dispose! out))) - (deftype UTF8InputStream [in bad-char] IUTF8InputStream (read-char [this] @@ -68,11 +67,15 @@ [o] (->UTF8OutputStream o)) -(defn utf8-output-stream-rf [output-stream] - (let [fp (utf8-output-stream output-stream)] - (fn ([] 0) - ([_] (dispose! fp)) - ([_ chr] - (assert (char? chr)) - (write-char fp chr) - nil)))) +(defn utf8-output-stream-rf + ([output-stream] + (utf8-output-stream-rf output-stream true)) + ([output-stream dispose?] + (let [fp (utf8-output-stream output-stream)] + (fn ([] 0) + ([_] (when dispose? + (dispose! fp))) + ([_ chr] + (assert (char? chr)) + (write-char fp chr) + nil))))) diff --git a/target2.py b/target2.py index 5b4e69f3..d3f7291a 100644 --- a/target2.py +++ b/target2.py @@ -24,7 +24,7 @@ def testit(max): #val = testit() #print val.int_val(), val -def entry_point(): +def entry_point(args): #s = rt.wrap(u"Foo") from pixie.vm2.string import String v = parse_number(u"1") @@ -129,4 +129,4 @@ def target(*args): if __name__ == "__main__": #run_debug(sys.argv) - entry_point() + entry_point([]) From 481d21c525c93518e7402d6af8bc08e0c9b88d29 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 1 Jun 2015 21:09:14 -0600 Subject: [PATCH 14/46] switched to pxic writer vs writing to python --- pixie/bootstrap.pxi | 8 - pixie/compiler.pxi | 474 +++++++++------------------------------ pixie/pxic-writer.pxi | 124 ++++++---- pixie/vm2/interpreter.py | 4 +- target2.py | 7 +- 5 files changed, 193 insertions(+), 424 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 37335933..f48571f0 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -709,11 +709,3 @@ new-array)) ;;; - - -(println (count (reduce - (fn [acc _] - (pop acc)) - - (into [] (range 1024)) - (range 1024)))) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 9d138875..5d89e745 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -459,17 +459,16 @@ [child]))) (:children ast))) -(defn collect-closed-overs [ast] - (post-walk - (fn [{:keys [op args env closed-overs] :as ast}] - (let [{:keys [locals]} env - closed-overs (set (or closed-overs - (mapcat :closed-overs (child-seq ast)))) - closed-overs (if (= op :fn-body) - (reduce disj closed-overs args) - closed-overs)] - (assoc ast :closed-overs closed-overs))) - ast)) +(def collect-closed-overs + (fn [{:keys [op args env closed-overs] :as ast}] + (let [{:keys [locals]} env + closed-overs (set (or closed-overs + (mapcat :closed-overs (child-seq ast)))) + closed-overs (if (= op :fn-body) + (reduce disj closed-overs args) + closed-overs)] + (assoc ast :closed-overs closed-overs))) + ast) (defn remove-env [ast] (walk #(dissoc % :env) @@ -477,379 +476,122 @@ :children ast)) -(defn convert-defs [ast] - (walk (fn [{:keys [op name env val form] :as ast}] - (if (= op :def) - {:op :invoke - :form form - :env env - :children '[:args] - :args [{:op :var - :ns "pixie.stdlib" - :name "set-var-root!"} - {:op :var - :ns (:ns env) - :name name - :form name} - val]} - - ast)) - identity - :children - ast)) +(defn make-invoke-ast [fn args form env] + {:op :invoke + :children '[:fn :args] + :form form + :env env + :fn fn + :args args}) -(defn pass-for [ast op-for f] - (walk (fn [{:keys [op] :as ast}] - (if (= op op-for) - (f ast) - ast)) - identity - :children - ast)) +(defn make-var-ast [ns name env] + {:op :var + :ns ns + :name name + :env env + :form (symbol (pixie.stdlib/name name))}) -(defn convert-fns [ast] - (pass-for ast :fn +(defn make-var-const-ast [ns name env] + {:op :var-const + :ns ns + :name name + :env env + :form (symbol (pixie.stdlib/name name))}) + +(defn make-invoke-var-ast [ns name args form env] + (make-invoke-ast + (make-var-ast ns name env) + args + form + env)) + +(def convert-defs + (fn [{:keys [op name env val form] :as ast}] + (if (= op :def) + (make-invoke-var-ast + "pixie.stdlib" + "set-var-root!" + [(make-var-const-ast (:ns env) name env) + val] + form + env) + ast)) + identity + :children + ast) + +(defn pass-for [op-for f] + (fn [{:keys [op] :as ast}] + (if (= op op-for) + (f ast) + ast))) + +(def convert-fns + (pass-for :fn (fn [{:keys [name arities form env]}] (if (= (count arities) 1) (convert-fn-body (first arities)) - {:op :invoke - :form form - :env env - :children '[:args] - :args (concat [{:op :var - :ns "pixie.stdlib" - :name "multi-arity-fn" - :env env - :form 'multi-arity-fn} - {:op :const - :form name - :env env}] - (mapcat - (fn [{:keys [args variadic?] :as body}] - [{:op :const - :form (if variadic? - -1 - (count args)) - :env env} - (convert-fn-body body)]) - arities))})))) + (make-invoke-var-ast + "pixie.stdlib" + "multi-arity-fn" + (concat [{:op :const + :form (str name) + :env env}] + (mapcat + (fn [{:keys [args variadic?] :as body}] + [{:op :const + :form (if variadic? + -1 + (count args)) + :env env} + (convert-fn-body body)]) + arities)) + form + env))))) + (defn convert-fn-body [{:keys [variadic? args body form env] :as ast}] (if variadic? - {:op :invoke - :form form - :env env - :children '[:args] - :args [{:op :var - :ns "pixie.stdlib" - :name "variadic-fn" - :form 'variadic-fn - :env :env} - {:op :const - :form (dec (count args)) - :env env} - (convert-fn-body (dissoc ast :variadic?))]} + (make-invoke-var-ast + "pixie.stdlib" + "variadic-fn" + [{:op :const + :form (dec (count args)) + :env env} + (convert-fn-body (dissoc ast :variadic?))] + form + env) (assoc ast :op :fn-body))) -(defn write! [{:keys [code] :as state} val] - (swap! code conj! val) - state) - -(defn add-meta [{:keys [meta-state meta-lines] :as state} ast] - (let [m (meta (:form ast))] - (if m - (let [k [(:line m) (:file m) (:line-number m)] - id (get @meta-state k)] - (if id - id - (let [id (str "mid" (count @meta-state))] - (swap! meta-state assoc k id) - (swap! meta-lines conj! (str id " = (u\"\"\"" (:line m) "\"\"\", \"" (:file m) "\", " (:line-number m) ")\n")) - id))) - "nil"))) - -(defn meta-str [state ast] - (let [m (meta (:form ast))] - (if m - (str "i.Meta(" (add-meta state ast) ", " (:column-number m) ")") - "nil"))) - -(defn offset-spaces [sb off] - (dotimes [x off] - (write! sb " "))) - -(defmulti to-rpython (fn [sb offset node] - (assert node) - (:op node))) - -(defmethod to-rpython :if - [sb offset {:keys [test then else] :as ast}] - (write! sb "i.If(\n") - (let [offset (inc offset)] - (doseq [[nm form] [[:test test] - [:then then] - [:els else]]] - (offset-spaces sb offset) - (write! sb (name nm)) - (write! sb "=") - (to-rpython sb offset form) - (write! sb ",\n")) - (offset-spaces sb offset) - (write! sb "meta=") - (write! sb (meta-str sb ast)) - - (write! sb ")"))) - -(defmulti write-const (fn [sb offset const] - (:type const))) - -(defmethod write-const :keyword - [sb offset {:keys [form]}] - (write! sb "kw(u\"") - (when (namespace form) - (write! sb (namespace form)) - (write! sb "/")) - (write! sb (name form)) - (write! sb "\")")) - -(defmethod write-const (keyword "nil") - [sb offset _] - (write! sb "nil")) - -(defmethod write-const :symbol - [sb offset {:keys [form]}] - (write! sb "sym(u\"") - (when (namespace form) - (write! sb (namespace form)) - (write! sb "/")) - (write! sb (name form)) - (write! sb "\")")) - -(defmethod write-const :string - [sb offset {:keys [form]}] - (write! sb "rt.wrap(u\"") - (write! sb form) - (write! sb "\")")) - -(defmethod write-const :number - [sb offset {:keys [form]}] - (write! sb "rt.wrap(") - (write! sb (str form)) - (write! sb ")")) - -(defmethod write-const :bool - [sb offset {:keys [form]}] - (if form - (write! sb "true") - (write! sb "false"))) - -(defmethod to-rpython :const - [sb offset ast] - (write! sb "i.Const(") - (write-const sb offset ast) - (write! sb ")")) - -(defmethod to-rpython :invoke - [sb offset ast] - (if (:tail-call ast) - (write! sb "i.TailCall(\n") - (write! sb "i.Invoke(\n")) - (let [offset (inc offset)] - (offset-spaces sb offset) - (write! sb "args=[\n") - (let [offset (inc offset)] - (doseq [x `(~(:fn ast) ~@(:args ast))] - (offset-spaces sb offset) - (to-rpython sb offset x) - (write! sb ",\n"))) - (offset-spaces sb offset) - (write! sb "],\n") - (offset-spaces sb offset) - (write! sb "meta=") - (write! sb (meta-str sb ast)) - (write! sb ")"))) - - -(defmethod to-rpython :do - [sb offset {:keys [ret statements] :as ast}] - (write! sb "i.Do(\n") - (let [offset (inc offset)] - (offset-spaces sb offset) - (write! sb "args=[\n") - (let [offset (inc offset)] - (doseq [x `(~@statements ~ret)] - (offset-spaces sb offset) - (to-rpython sb offset x) - (write! sb ",\n"))) - (offset-spaces sb offset) - (write! sb "],\n")) - (offset-spaces sb offset) - (write! sb "meta=") - (write! sb (meta-str sb ast)) - (write! sb ")")) - - -(defmethod to-rpython :fn - [sb offset {:keys [name arities]}] - (if (= (count arities) 1) - (to-rpython-fn-body sb offset name (nth arities 0)) - (do (write! sb (str "i.Invoke([i.Const(code.intern_var(u\"pixie.stdlib\", u\"multi-arity-fn\")), i.Const(rt.wrap(u\"" name "\")),\n")) - (offset-spaces sb offset) - (let [offset (inc offset)] - (doseq [f arities] - (when (not (:variadic? f)) - (offset-spaces sb offset) - (write! sb (str "i.Const(rt.wrap(" (count (:args f)) ")), ")) - (to-rpython-fn-body sb offset name f) - (write! sb ",\n"))) - (offset-spaces sb offset) - (let [vfn (first (filter :variadic? arities))] - (when vfn - (offset-spaces sb offset) - (write! sb (str "i.Const(rt.wrap(-1)), \n")) - (offset-spaces sb offset) - (to-rpython-fn-body sb offset name vfn) - (write! sb "\n")))) - (offset-spaces sb offset) - (write! sb "])")))) - -(defn to-rpython-fn-body - [sb offset name {:keys [args body variadic? closed-overs] :as ast}] - (when variadic? - (write! sb (str "i.Invoke([i.Const(code.intern_var(u\"pixie.stdlib\", u\"variadic-fn\")), i.Const(rt.wrap(" (dec (count args)) ")), \n")) - (offset-spaces sb offset)) - (write! sb "i.Fn(args=[") - (write! sb (->> args - (map (fn [name] - (str "kw(u\"" name "\")"))) - (interpose ",") - (apply str))) - (write! sb "],name=kw(u\"") - (write! sb (str name)) - (write! sb "\"),") - (when (not (empty? closed-overs)) - (write! sb "closed_overs=[") - (write! sb (->> closed-overs - (map (fn [name] - (str "kw(u\"" name "\")"))) - (interpose ",") - (apply str))) - (write! sb "],")) - (write! sb "\n") - (let [offset (inc offset)] - (offset-spaces sb offset) - (write! sb "body=") - (to-rpython sb offset body) - (write! sb ",\n")) - (offset-spaces sb offset) - (write! sb ")") - (if variadic? - (write! sb "])"))) - -(defmethod to-rpython :var - [sb offset {:keys [ns name] :as ast}] - (write! sb "i.VDeref(code.intern_var(") - (write! sb "u\"") - (write! sb ns) - (write! sb "\", u\"") - (write! sb name) - (write! sb "\"), meta=") - (write! sb (meta-str sb ast)) - (write! sb ")")) - -(defmethod to-rpython :binding - [sb offset {:keys [name] :as ast}] - (write! sb "i.Lookup(kw(u\"") - (write! sb name) - (write! sb "\"), meta=") - (write! sb (meta-str sb ast)) - (write! sb ")")) - -(defmethod to-rpython :def - [sb offset {:keys [name env val]}] - (write! sb "i.Invoke(args=[\n") - (write! sb (str "# (def " (:ns env) "/" name ")\n")) - (let [offset (inc offset)] - (offset-spaces sb offset) - (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"set-var-root!\")),\n") - (offset-spaces sb offset) - (write! sb "i.Const(code.intern_var(u\"") - (write! sb (:ns env)) - (write! sb "\",u\"") - (write! sb name) - (write! sb "\")),\n") - (offset-spaces sb offset) - (to-rpython sb offset val) - (write! sb "])") - )) +(def convert-vectors + (pass-for :vector + (fn [{:keys [items form env]}] + (make-invoke-var-ast + "pixie.stdlib" + "array" + items + form + env)))) + +(defn run-passes [ast] + (walk identity + (comp + convert-vectors + convert-fns + (comp convert-defs + collect-closed-overs + clean-do)) + :children + ast)) -(defmethod to-rpython :vector - [sb offset {:keys [items]}] - (write! sb "i.Invoke(args=[\n") - (let [offset (inc offset)] - (offset-spaces sb offset) - (write! sb "i.Const(code.intern_var(u\"pixie.stdlib\", u\"array\")),") - (doseq [item items] - (offset-spaces sb offset) - (to-rpython sb offset item) - (write! sb ",\n")) - (offset-spaces sb offset) - (write! sb "])"))) - -(defmethod to-rpython :let - [sb offset {:keys [bindings body] :as ast}] - (write! sb "i.Let(names=[") - (write! sb (->> bindings - (map (fn [binding] - (str "kw(u\"" (:name binding) "\")"))) - (interpose ",") - (apply str))) - (write! sb "],\n") - - (offset-spaces sb offset) - (write! sb "bindings=[\n") - (let [offset (inc offset)] - (doseq [{:keys [value]} bindings] - (offset-spaces sb offset) - (to-rpython sb offset value) - (write! sb ",\n")) - (offset-spaces sb offset) - (write! sb "],\n") - - (offset-spaces sb offset) - - (write! sb "body=") - (to-rpython sb offset body) - (write! sb ",\n") - - (offset-spaces sb offset) - (write! sb "meta=") - (write! sb (meta-str sb ast)) - - - (write! sb ")"))) - - - -(defn writer-context [] - {:meta-lines (atom (string-builder)) - :meta-state (atom {}) - :code (atom (string-builder))}) - -(defn finish-context [{:keys [meta-lines code]}] - (str (string-builder @meta-lines) - "\n \n" - "code_ast=" - (string-builder @code))) (println "Reading") (let [form (time (read-string (str "(do " (pixie.io/slurp "pixie/bootstrap.pxi") ")"))) _ (println "Compiling") ast (time (analyze form)) _ (println "Passes") - ast (time (convert-fns (convert-defs (collect-closed-overs (clean-do ast))))) + ast (time (run-passes ast)) _ (println "To String") - ;str (time (finish-context (to-rpython (writer-context) 0 ast))) os (-> "/tmp/bootstrap.pxic" io/open-write io/buffered-output-stream)] diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index 4d57a19b..9a8e2d85 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -23,24 +23,24 @@ :FLOAT :INT-STRING :STRING - :AST :TRUE :FALSE :NIL :VAR :KEYWORD :SYMBOL - :NEW-CACHED-OBJECT]) - - -(defbytecodes - [:DO + :NEW-CACHED-OBJECT + :DO :INVOKE :VAR :CONST :FN :LOOKUP - :IF]) + :IF + :LET + :META + :LINE-META + :VAR-CONST]) (def *cache* nil) (set-dynamic! (var *cache*)) @@ -57,13 +57,10 @@ (deftype WriterCache [os cache] IWriterCache (write-cached-obj [this val wfn] - (println "Cache" (cache val) val) (if-let [idx (cache val)] (do (write-tag os CACHED-OBJECT) - (write-int-raw os idx) - (println "Wrote cached")) + (write-int-raw os idx)) (let [idx (count cache)] - (println "writing uncached") (set-field! this :cache (assoc cache val idx)) (write-tag os NEW-CACHED-OBJECT) (apply wfn val))))) @@ -74,7 +71,6 @@ (defn write-raw-string [os str] (write-int-raw os (count str)) - (println "spit " str) (spit os str false)) (defn write-int-raw [os i] @@ -93,6 +89,17 @@ (do (write-byte os INT-STRING) (write-raw-string os (str i))))) +(defn write-meta [os ast] + (let [m (meta (:form ast))] + (if m + (write-object os {:op :meta + :line {:op :line-meta + :line (str (:line m)) + :file (:file m) + :line-number (:line-number m)} + :column-number (:column-number m)}) + (write-object os nil)))) + (defn write-tag [os tag] (write-byte os tag)) @@ -103,43 +110,48 @@ (:op ast))) (defmethod write-ast :do - [os {:keys [statements ret]}] - (write-tag os AST) + [os {:keys [statements ret] :as ast}] (write-tag os DO) (write-int-raw os (inc (count statements))) (doseq [statement statements] (write-object os statement)) - (write-object os ret)) + (write-object os ret) + (write-meta os ast)) (defmethod write-ast :invoke - [os {:keys [args]}] - (write-tag os AST) + [os {:keys [fn args] :as ast}] (write-tag os INVOKE) - (write-int-raw os (count args)) + (write-int-raw os (inc (count args))) + (write-object os fn) (doseq [arg args] - (write-object os arg))) + (write-object os arg)) + (write-meta os ast)) (defmethod write-ast :var [os {:keys [ns name]}] (write-cached-obj *cache* - [ns name] - (fn [ns name] - (write-tag os AST) + [:deref ns name] + (fn [_ ns name] (write-tag os VAR) (write-raw-string os (str ns)) (write-raw-string os (str name))))) +(defmethod write-ast :var-const + [os {:keys [ns name]}] + (write-cached-obj *cache* + [:const ns name] + (fn [_ ns name] + (write-tag os VAR-CONST) + (write-raw-string os (str ns)) + (write-raw-string os (str name))))) + (defmethod write-ast :const [os {:keys [form]}] - (write-cached-obj *cache* - [form] - (fn [form] - (write-tag os CONST) - (write-object os form)))) + (write-tag os CONST) + (write-object os form)) (defmethod write-ast :fn-body - [os {:keys [name args closed-overs body]}] - (write-tag os AST) + [os {:keys [name args closed-overs body] :as ast}] (write-tag os FN) (write-raw-string os (str name)) (write-int-raw os (count args)) @@ -148,41 +160,67 @@ (write-int-raw os (count closed-overs)) (doseq [co closed-overs] (write-object os (keyword (str co)))) - (write-object os body)) + (write-object os body) + (write-meta os ast)) (defmethod write-ast :binding - [os {:keys [name]}] - (write-tag os AST) + [os {:keys [name] :as ast}] (write-tag os LOOKUP) - (write-object os (keyword (pixie.stdlib/name name)))) + (write-object os (keyword (pixie.stdlib/name name))) + (write-meta os ast)) (defmethod write-ast :if - [os {:keys [test then else]}] - (write-tag os AST) + [os {:keys [test then else] :as ast}] (write-tag os IF) (write-object os test) (write-object os then) - (write-object os else)) + (write-object os else) + (write-meta os ast)) + +(defmethod write-ast :let + [os {:keys [bindings body] :as ast}] + (write-tag os LET) + (write-int-raw os (count bindings)) + (doseq [{:keys [name value]} bindings] + (write-object os name) + (write-object os value)) + (write-object os body) + (write-meta os ast)) + +(defmethod write-ast :meta + [os {:keys [line column-number]}] + (write-tag os META) + (write-object os line) + (write-int-raw os column-number)) + +(defmethod write-ast :line-meta + [os ast] + (write-cached-obj *cache* + [:line-meta ast] + (fn [_ {:keys [line file line-number]}] + (write-tag os LINE-META) + (write-raw-string os file) + (write-raw-string os line) + (write-int-raw os line-number)))) (extend-protocol IPxicObject IMap (-write-object [this os] - (println (keys this)) (write-ast os this)) String (-write-object [this os] (write-cached-obj *cache* - [this] - (fn [this] + [:string this] + (fn [_ this] (write-tag os STRING) (write-raw-string os this)))) Keyword (-write-object [this os] (write-cached-obj *cache* - [this] - (fn [this] + [:keyword this] + (fn [_ this] (write-tag os KEYWORD) (if (namespace this) (write-raw-string os (str (namespace this) "/" (name this))) @@ -191,8 +229,8 @@ Symbol (-write-object [this os] (write-cached-obj *cache* - [this] - (fn [this] + [:symbol this] + (fn [_ this] (write-tag os SYMBOL) (if (namespace this) (write-raw-string os (str (namespace this) "/" (name this))) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index b4262bb3..72332baa 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -19,7 +19,7 @@ def get_short_location(self): def get_long_location(self): if self._c_meta != nil: return self._c_meta.get_long_location() - return "" + return "" class Meta(Object): _type = Type(u"pixie.stdlib.Meta") @@ -233,7 +233,7 @@ def get_ast(self): class Let(AST): _immutable_fields_ = ["_c_names", "_c_bindings", "_c_body"] - def __init__(self, names, bindings, body, meta): + def __init__(self, names, bindings, body, meta=nil): AST.__init__(self, meta) self._c_names = names self._c_bindings = bindings diff --git a/target2.py b/target2.py index d3f7291a..efa3d7ef 100644 --- a/target2.py +++ b/target2.py @@ -8,15 +8,13 @@ from pixie.vm2.keyword import keyword as kw from pixie.vm2.symbol import symbol as sym from pixie.vm2.numbers import parse_number - +from pixie.vm2.pxic_reader import read_file rt.init() -with open("bootstrap.py") as f: - exec f.read() - pixie_code = code_ast def testit(max): + pixie_code = read_file("/tmp/bootstrap.pxic") return run_stack(None, i.InterpretK(pixie_code, None)) @@ -33,7 +31,6 @@ def entry_point(args): max = 10000 #int(args[1]) val = testit(max) - print val return 43 ## JIT STUFF From 87dee61f2b848bd8fffcd442b7d5c996b0584661 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 2 Jun 2015 06:25:54 -0600 Subject: [PATCH 15/46] fixed up the compiler a bit. Now works with in-ns in bootstrap.pxi --- pixie/compiler.pxi | 103 +++++++++++++++++++++++------------------- pixie/pxic-writer.pxi | 6 ++- 2 files changed, 61 insertions(+), 48 deletions(-) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 5d89e745..db60e753 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -372,35 +372,44 @@ resolved (try (resolve-in namesp x) (catch :pixie.stdlib/AssertionException ex - nil))] - (cond - (namespace x) - {:op :var - :env *env* - :ns (symbol (namespace x)) - :name (symbol (name x)) - :form x} - - (get-in @(:vars *env*) [(:ns *env*) x]) - {:op :var - :env *env* - :ns (:ns *env*) - :name x - :form x} - - resolved - {:op :var - :env *env* - :ns (namespace resolved) - :name (name resolved) - :form x} - - :else - {:op :var - :env *env* - :ns (name (:ns *env*)) - :name (name x) - :form x}))) + nil)) + result (cond + (namespace x) + {:op :var + :env *env* + :ns (symbol (namespace x)) + :name (symbol (name x)) + :form x} + + (get-in @(:vars *env*) [(:ns *env*) x]) + {:op :var + :env *env* + :ns (:ns *env*) + :name x + :form x} + + ;; Hack until we get proper refers + (get-in @(:vars *env*) ['pixie.stdlib x]) + {:op :var + :env *env* + :ns 'pixie.stdlib + :name x + :form x} + + resolved + {:op :var + :env *env* + :ns (namespace resolved) + :name (name resolved) + :form x} + + :else + {:op :var + :env *env* + :ns (name (:ns *env*)) + :name (name x) + :form x})] + result)) ;; ENV Functions @@ -409,7 +418,7 @@ "Creates a new (empty) environment" [] {:ns 'pixie.stdlib - :vars (atom nil) + :vars (atom {'pixie.stdlib {'array true}}) :tail? true}) @@ -530,27 +539,27 @@ (pass-for :fn (fn [{:keys [name arities form env]}] (if (= (count arities) 1) - (convert-fn-body (first arities)) + (convert-fn-body name (first arities)) (make-invoke-var-ast "pixie.stdlib" "multi-arity-fn" - (concat [{:op :const - :form (str name) - :env env}] - (mapcat - (fn [{:keys [args variadic?] :as body}] - [{:op :const - :form (if variadic? - -1 - (count args)) - :env env} - (convert-fn-body body)]) - arities)) + (vec (concat [{:op :const + :form (pixie.stdlib/name name) + :env env}] + (mapcat + (fn [{:keys [args variadic?] :as body}] + [{:op :const + :form (if variadic? + -1 + (count args)) + :env env} + (convert-fn-body name body)]) + arities))) form env))))) -(defn convert-fn-body [{:keys [variadic? args body form env] :as ast}] +(defn convert-fn-body [name {:keys [variadic? args body form env] :as ast}] (if variadic? (make-invoke-var-ast "pixie.stdlib" @@ -558,10 +567,12 @@ [{:op :const :form (dec (count args)) :env env} - (convert-fn-body (dissoc ast :variadic?))] + (convert-fn-body name (dissoc ast :variadic?))] form env) - (assoc ast :op :fn-body))) + (assoc ast + :op :fn-body + :name name))) (def convert-vectors (pass-for :vector diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index 9a8e2d85..1b91017c 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -70,6 +70,8 @@ (->WriterCache os {})) (defn write-raw-string [os str] + (assert (not= str "nil")) + (assert (string? str) "Expected String") (write-int-raw os (count str)) (spit os str false)) @@ -224,7 +226,7 @@ (write-tag os KEYWORD) (if (namespace this) (write-raw-string os (str (namespace this) "/" (name this))) - (write-raw-string os (str this)))))) + (write-raw-string os (name this)))))) Symbol (-write-object [this os] @@ -234,7 +236,7 @@ (write-tag os SYMBOL) (if (namespace this) (write-raw-string os (str (namespace this) "/" (name this))) - (write-raw-string os (str this)))))) + (write-raw-string os (name this)))))) Integer (-write-object [this os] From 80fc2fad0502b205cc9ffe372f8e0d98ed168817 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 2 Jun 2015 23:12:15 -0600 Subject: [PATCH 16/46] implemented delimited continuations in the VM. Just needs some macro sugar and some JIT work --- pixie/bootstrap.pxi | 88 ++++++++++++++++++++++++++++++++- pixie/compiler.pxi | 11 +++-- pixie/pxic-writer.pxi | 14 ++++-- pixie/vm2/interpreter.py | 103 ++++++++++++++++++++++++++++++++++++++- pixie/vm2/stdlib.py | 11 ++++- 5 files changed, 216 insertions(+), 11 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index f48571f0..16c0c721 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -80,6 +80,9 @@ (defprotocol IToTransient (-transient [this x])) +(defprotocol ITransient + (-persistent! [this])) + (defprotocol ITransientStack (-push! [this x]) (-pop! [this])) @@ -593,7 +596,14 @@ (if (= idx cnt) (-conj this val) (throw [:pixie.stdlib/IndexOutOfRange - "Can only assoc to the end or the contents of a vector"]))))) + "Can only assoc to the end or the contents of a vector"])))) + + IToTransient + (-transient [this] + (->TransientVector cnt shift + (editable-root root) + (editable-tail tail) + meta))) (defn do-assoc [lvl node idx val] (let [new-array (array-clone (.-array node)) @@ -662,6 +672,70 @@ (->PersistentVector (count arr) 5 EMPTY-NODE arr nil) (into [] arr))) + +;; Transient Vector + +#_(deftype Edited []) +(def edited ::edited) + + +(deftype TransientVector [cnt shift root tail meta] + IMessageObject + (-get-field [this field] + (get-field this field)) + + ITransientCollection + (-conj! [this val] + (ensure-editable this) + (let [i cnt] + (if (< (- i (tail-off this) 32)) + (do (aset tail (bit-and i 0x01F) val) + (set-field! this :cnt (inc cnt)) + this) + (let [tail-node (->Node (.-edit root) tail)] + (set-field! this :tail (make-array 32)) + (aset tail 0 val) + (if (> (bit-shift-right cnt 5) + (bit-shift-left 1 shift)) + (let [root-array (make-array 32)] + (aset root-array 0 root) + (aset root-array 1 (new-path (.-edit root) shift tail-node)) + (set-field! this :shift (+ shift 5)) + (set-field! this :root new-root) + (set-field! this :cnt (inc cnt)) + this) + (do (set-field this :root (push-tail-transient shift root tail-node)) + (set-field this :cnt (inc cnt)) + this)))))) + + ITransient + (-persistent! [this] + (ensure-editable this) + (let [trimmed (make-array (- cnt (tail-off self)))] + (array-copy tail 0 trimmed 0 (count trimmed)) + (->PersistentVector cnt shift root trimmed))) + +) + + +(defn editable-root [node] + (->Node edited (array-clone (.-array node)))) + +(defn ensure-editable [node] + (assert (not (nil? (.-edit node))) + "Transient used after call to persist!")) + +(defn ensure-node-editable [this node] + (let [root (.-root this)] + (if (identical? (.-edit node) (.-edit root)) + node + (->Node (.-edit root) (.-array node))))) + +(defn editable-tail [tail] + (let [ret (make-array 32)] + (acopy tail 0 ret 0 (count tail)) + ret)) + (in-ns :pixie.stdlib) ;; Extend Array @@ -709,3 +783,15 @@ new-array)) ;;; + + +(def decide (-effect-fn (fn [h k] + (println "Calling.." h) + [(k 41) + (k 42)]))) +(println true) +(-with-handler :foo + (fn [] + + (println (decide :foo)) + )) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index db60e753..0c08cb00 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -228,13 +228,13 @@ (defmethod analyze-seq 'loop* [[_ bindings & body]] (let [parted (partition 2 bindings)] - (analyze-form `((fn __loop__fn__ ~(mapv first parted) + (analyze-form `((fn ~'__loop__fn__ ~(mapv first parted) ~@body) ~@(mapv second parted))))) (defmethod analyze-seq 'recur [[_ & args]] - (analyze-form `(__loop__fn__ ~@args))) + (analyze-form `(~'__loop__fn__ ~@args))) (defmethod analyze-seq 'def [[_ nm val :as form]] @@ -301,9 +301,10 @@ (cond (and (symbol? sym) (string/starts-with? (name sym) ".-")) - (let [sym-kw (keyword (string/substring (name sym) 2))] - (analyze-form (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw) - form))) + (let [sym-kw (keyword (string/substring (name sym) 2)) + result (analyze-form (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw) + form))] + result) (contains? macro-overrides resolved) (analyze-form (keep-meta (apply (macro-overrides resolved) args) diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index 1b91017c..f50e11eb 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -45,6 +45,9 @@ (def *cache* nil) (set-dynamic! (var *cache*)) +(def *old-meta* nil) +(set-dynamic! (var *old-meta*)) + (defprotocol IWriterCache (write-cached-obj [this val wfn])) @@ -92,7 +95,8 @@ (write-raw-string os (str i))))) (defn write-meta [os ast] - (let [m (meta (:form ast))] + (let [m (or (meta (:form ast)) + *old-meta*)] (if m (write-object os {:op :meta :line {:op :line-meta @@ -184,7 +188,7 @@ (write-tag os LET) (write-int-raw os (count bindings)) (doseq [{:keys [name value]} bindings] - (write-object os name) + (write-object os (keyword (pixie.stdlib/name name))) (write-object os value)) (write-object os body) (write-meta os ast)) @@ -254,4 +258,8 @@ (defn write-object [os ast] - (-write-object ast os)) + (binding [*old-meta* (or (and + (map? ast) + (meta (:form ast))) + *old-meta*)] + (-write-object ast os))) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 72332baa..f344b99d 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -1,7 +1,8 @@ -from pixie.vm2.object import Object, Type, Continuation, stack_cons, runtime_error +from pixie.vm2.object import Object, Type, Continuation, stack_cons, runtime_error, affirm from pixie.vm2.primitives import nil, false from pixie.vm2.array import Array import pixie.vm2.code as code +from pixie.vm2.keyword import Keyword from pixie.vm2.code import BaseCode import rpython.rlib.jit as jit @@ -82,6 +83,7 @@ def interpret(self, _, locals, stack): class Locals(object): _immutable_ = True def __init__(self, name, value, next): + assert isinstance(name, Keyword) self._c_value = value self._c_name = name self._c_next = next @@ -99,6 +101,7 @@ def get_local(self, name): class Lookup(AST): _immutable_fields_ = ["_c_name"] def __init__(self, name, meta=nil): + assert isinstance(name, Keyword) AST.__init__(self, meta) self._c_name = name @@ -126,6 +129,7 @@ def interpret(self, _, locals, stack): class InterpretedFn(code.BaseCode): _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name", "_c_arg_names"] def __init__(self, name, arg_names, locals_prefix, ast): + assert isinstance(name, Keyword) code.BaseCode.__init__(self) self._c_arg_names = arg_names self._c_name = name @@ -391,3 +395,100 @@ def print_stacktrace(cont, stack): +## Handler code + + +class WithHandler(code.BaseCode): + def __init__(self): + BaseCode.__init__(self) + + def invoke_k(self, args, stack): + affirm(len(args) == 2, u"-with-handler takes one argument") + handler = args[0] + fn = args[1] + + stack = stack_cons(stack, Handler(handler)) + return fn.invoke_k([], stack) + + + +class Handler(Continuation): + _immutable_ = True + def __init__(self, handler): + self._handler = handler + + def handler(self): + return self._handler + + def get_ast(self): + return None + +class DelimitedContinuation(code.NativeFn): + _immutable_fields_ = ["_slice[*]"] + def __init__(self, slice): + self._slice = slice + + @jit.unroll_safe + def invoke_k(self, args, stack): + affirm(len(args) == 1, u"Delmited continuations only take one argument") + for x in range(len(self._slice)): + stack = stack_cons(stack, self._slice[x]) + return args[0], stack + +class EffectFunction(code.BaseCode): + def __init__(self, inner_fn): + BaseCode.__init__(self) + self._inner_fn = inner_fn + + def invoke_k(self, args, stack): + affirm(len(args) >= 1, u"Effect functions require at least one argument") + handler = args[0] + + stack, slice = self.slice_stack(stack, handler) + + new_args = self.append_args(args, DelimitedContinuation(slice)) + + return self._inner_fn.invoke_k(new_args, stack) + + + @jit.unroll_safe + def append_args(self, args, val): + new_args = [None] * (len(args) + 1) + for x in range(len(args)): + new_args[x] = args[x] + + new_args[(len(args))] = val + + return new_args + + @jit.unroll_safe + def slice_stack(self, orig_stack, handler): + + size = 0 + stack = orig_stack + while True: + if stack is None: + ## No hander found + size = -1 + break + + if isinstance(stack._cont, Handler) and stack._cont.handler() is handler: + break + + size += 1 + stack = stack._parent + + slice = [None] * size + + stack = orig_stack + for x in range(size - 1, -1, -1): + slice[x] = stack._cont + stack = stack._parent + + return stack, slice + + + + + + diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 7dc112a6..4cef8645 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -5,6 +5,7 @@ import pixie.vm2.code as code import pixie.vm2.array as array from rpython.rlib.rarithmetic import r_uint +import pixie.vm2.interpreter as interpreter import rpython.rlib.jit as jit @as_var("set-var-root!") @@ -75,6 +76,13 @@ def _variadic_fn(required_arity, fn): arity = required_arity.int_val() return code.VariadicCode(required_arity=arity, code=fn) +@as_var("-effect-fn") +def _variadic_fn(inner_fn): + + return interpreter.EffectFunction(inner_fn) + +as_var("-with-handler")(interpreter.WithHandler()) + @as_var("multi-arity-fn") def _multi_arity_fn__args(args): from pixie.vm2.string import String @@ -172,4 +180,5 @@ def _add_to_string_builder(sb, x): @as_var("-finish-string-builder") def _finish_string_builder(sb): - return rt.wrap(sb.to_str()) \ No newline at end of file + return rt.wrap(sb.to_str()) + From 412e0ed36f5a808a7c79b8a4cd52bcf3dd2a298c Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sat, 6 Jun 2015 15:55:41 -0600 Subject: [PATCH 17/46] implemented hashing and SizeT math --- pixie/bootstrap.pxi | 483 ++++++++++++++++++++++++++++++++------- pixie/compiler.pxi | 3 +- pixie/pxic-writer.pxi | 8 +- pixie/stdlib.pxi | 20 ++ pixie/vm2/bits.py | 76 +++--- pixie/vm2/interpreter.py | 5 + pixie/vm2/numbers.py | 28 ++- pixie/vm2/object.py | 8 + pixie/vm2/rt.py | 2 + pixie/vm2/stdlib.py | 12 + 10 files changed, 527 insertions(+), 118 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 16c0c721..b52b936e 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -95,6 +95,10 @@ (-invoke-method [this name args])) +(defprotocol IEffect + (-effect-val [this v]) + (-effect-return [this v])) + (extend -get-field Object -internal-get-field) @@ -133,7 +137,20 @@ ([x] x) ([x y] (-sub x y)) ([x y & more] - (-apply - (- x y) more))) + (-apply - (- x y) more))) + +(defn * + ([] 1) + ([x] x) + ([x y] (-mul x y)) + ([x y & args] + (reduce -mul (-mul x y) args))) + +(defn / + ([x] (-div 1 x)) + ([x y] (-div x y)) + ([x y & args] + (reduce -div (-div x y) args))) (defn inc ([x] (+ x 1))) @@ -180,6 +197,17 @@ (apply = y rest) false))) +;; Base functions + +(defn hash + [this] + (-hash this)) + +(defn identity + ^{:doc "The identity function. Returns its argument." + :added "0.1"} + ([x & _] x)) + (defn not [x] (if x false true)) @@ -193,16 +221,62 @@ (identical? x nil)) (defn conj + {:doc "Adds elements to the transient collection. Elements are added to the end except in the case of Cons lists" + :signatures [[] [coll] [coll item] [coll item & args]] + :added "0.1"} ([] []) ([coll] coll) ([coll itm] (-conj coll itm)) ([coll item & more] (-apply conj (conj x y) more))) + +(defn conj! + {:doc "Adds elements to the transient collection. Elements are added to the end except in the case of Cons lists" + :signatures [[] [coll] [coll item] [coll item & args]] + :added "0.1"} + ([] (-transient [])) + ([coll] (-persistent! coll)) + ([coll item] (-conj! coll item)) + ([coll item & args] + (reduce -conj! (-conj! coll item) args))) + +(defn disj + {:doc "Removes elements from the collection." + :signatures [[] [coll] [coll item]] + :added "0.1"} + ([] []) + ([coll] coll) + ([coll item] (-disj coll item)) + ([coll item & items] + (reduce -disj (-disj coll item) items))) + (defn pop + {:doc "Pops elements off a stack." + :signatures [[] [coll] [coll item] [coll item & args]] + :added "0.1"} ([] []) ([coll] (-pop coll))) +(defn push + {:doc "Push an element on to a stack." + :signatures [[] [coll] [coll item] [coll item & args]] + :added "0.1"} + ([coll x] (-push coll x))) + +(defn pop! + {:doc "Pops elements off a transient stack." + :signatures [[] [coll] [coll item] [coll item & args]] + :added "0.1"} + ([coll] (-pop! coll))) + +(def push! + {:doc "Push an element on to a transient stack." + :signatures [[] [coll] [coll item] [coll item & args]] + :added "0.1"} + ([coll x] (-push! coll x))) + + (defn nth {:doc "Returns the element at the idx. If the index is not found it will return an error. However, if you specify a not-found parameter, it will substitute that instead" @@ -262,24 +336,100 @@ ;; -;; Type Helpers +;; Hashing Functions +(in-ns :pixie.stdlib.hashing) + + +(def seed 0) +(def C1 (size-t 0xcc9e2d51)) +(def C2 (size-t 0x1b873593)) +(def LONG-BIT (size-t 32)) +(def MASK-32 (size-t 0xFFFFFFFF)) + +(defn mask-32 [x] + (bit-and x MASK-32)) + +(defn rotr [value shift] + (let [value (size-t value) + shift (size-t shift)] + (bit-or (bit-shift-left value shift) + (bit-shift-right value (- LONG-BIT shift))))) + +(defn rotl [value shift] + (let [value (size-t value) + shift (size-t shift)] + (println (type value) (type LONG-BIT) (type shift) (type (- LONG-BIT shift))) + (bit-or (bit-shift-right value shift) + (bit-shift-left value (- LONG-BIT shift))))) + +(defn mix-k1 [k1] + (let [k1 (* k1 C1) + k1 (rotl k1 15) + k1 (* k1 C2)] + k1)) + +(defn mix-h1 [h1 k1] + (let [h1 (bit-xor h1 k1) + h1 (rotr h1 13) + h1 (+ (* h1 5) 0xe6546b64)] + h1)) + + +(defn fmix [h1 length] + (let [h1 (bit-xor h1 length) + h1 (bit-xor h1 (bit-shift-right h1 16)) + h1 (* h1 0x85ebca6b) + h1 (bit-xor h1 (bit-shift-right h1 13)) + h1 (* h1 0xc2b2ae35) + h1 (bit-xor h1 (bit-shift-right h1 16))] + h1)) -(defn instance? - ^{:doc "Checks if x is an instance of t. - When t is seqable, checks if x is an instance of - any of the types contained therein." - :signatures [[t x]]} - [t x] - (if (-satisfies? ISeqable t) - (let [ts (seq t)] - (if (not ts) false - (if (-instance? (first ts) x) - true - (instance? (rest ts) x)))) - (-instance? t x))) -;; End Type Helpers +(defn mix-coll-hash [hash count] + (let [h1 seed + k1 (mix-k1 hash) + h1 (mix-h1 h1 k1)] + (fmix h1 count))) + +(deftype HashingState [n hash] + IMessageObject + (-get-field [this field] + (get-field this field))) + +(defn unordered-hashing-rf + ([] (->HashingState (size-t 0) (size-t 1))) + ([acc] + (mix-coll-hash (.-hash acc) + (.-n acc))) + ([acc itm] + (set-field! acc :n (inc (.-n acc))) + (set-field! acc :hash (+ (.-hash acc) + (hash itm))))) + +(defn ordered-hashing-rf + ([] (->HashingState 0 1)) + ([acc] + (mix-coll-hash (.-hash acc) + (.-n acc))) + ([acc itm] + (set-field! acc :n (inc (.-n acc))) + (set-field! acc :hash (+ (* (size-t 31) (.-hash acc)) + (hash itm))))) + + + +(defn hash-int [input] + (if (= input 0) + 0 + (let [k1 (mix-k1 input) + h1 (mix-h1 seed k1)] + (fmix h1 4)))) + +(in-ns :pixie.stdlib) + +;; End Hashing Functions + ;; Reduced @@ -295,25 +445,6 @@ ;; End Reduced -;; Satisfies - -(defn satisfies? - ^{:doc "Checks if x satisfies the protocol p. - - When p is seqable, checks if x satisfies all of - the protocols contained therein." - :signatures [[t x]]} - [p x] - (if (-satisfies? ISeqable p) - (let [ps (seq p)] - (if (not ps) true - (if (not (-satisfies? (first ps) x)) - false - (satisfies? (rest ps) x)))) - (-satisfies? p x))) - -;; End Satisfies - ;; Basic Transducer Support (defn transduce @@ -331,7 +462,7 @@ (defn reduce ([rf col] - (reduce rf (rf) col)) + (rf (reduce rf (rf) col))) ([rf init col] (-reduce col rf init))) @@ -376,8 +507,108 @@ nil)))))] (map (fn [args] (apply f args)) (step colls))))) + +(defn interpose + ^{:doc "Returns a transducer that inserts `val` in between elements of a collection." + :signatures [[val] [val coll]] + :added "0.1"} + ([val] (fn [xf] + (let [first? (atom true)] + (fn + ([] (xf)) + ([result] (xf result)) + ([result item] (if @first? + (do (reset! first? false) + (xf result item)) + (xf (xf result val) item))))))) + ([val coll] + (transduce (interpose val) conj coll))) + + +(def preserving-reduced + (fn preserving-reduced [rf] + (fn pr-inner [a b] + (let [ret (rf a b)] + (if (reduced? ret) + (reduced ret) + ret))))) + +(defn cat + {:doc "A transducer that concatenates elements of a collection." + :added "0.1"} + [rf] + (let [rrf (preserving-reduced rf)] + (fn cat-inner + ([] (rf)) + ([result] (rf result)) + ([result input] + (reduce rrf result input))))) + +(defn mapcat + {:doc "Maps f over the elements of coll and concatenates the result" + :added "0.1"} + ([f] + (comp (map f) cat)) + ([f coll] + (transduce (mapcat f) conj coll))) + + ;; End Basic Transudcer Support +;; Type Checks + +(defn instance? [t x] + {:doc "Checks if x is an instance of t. + + When t is seqable, checks if x is an instance of + any of the types contained therein." + :signatures [[t x]]} + (if (-satisfies? ISeqable t) + (let [ts (seq t)] + (if (not ts) false + (if (-instance? (first ts) x) + true + (instance? (rest ts) x)))) + (-instance? t x))) + +(defn satisfies? [p x] + ^{:doc "Checks if x satisfies the protocol p. + + When p is seqable, checks if x satisfies all of + the protocols contained therein." + :signatures [[t x]]} + (if (-satisfies? ISeqable p) + (let [ps (seq p)] + (if (not ps) true + (if (not (-satisfies? (first ps) x)) + false + (satisfies? (rest ps) x)))) + (-satisfies? p x))) + + +(defn true? [v] (identical? v true)) +(defn false? [v] (identical? v false)) + +(defn number? [v] (instance? Number v)) +(defn integer? [v] (instance? Integer v)) +(defn float? [v] (instance? Float v)) +(defn ratio? [v] (instance? Ratio v)) + +(defn char? [v] (instance? Character v)) +(defn string? [v] (instance? String v)) +(defn keyword? [v] (instance? Keyword v)) + +(defn list? [v] (instance? [PersistentList Cons] v)) +(defn set? [v] (instance? PersistentHashSet v)) +(defn map? [v] (satisfies? IMap v)) +(defn fn? [v] (satisfies? IFn v)) + +(defn indexed? [v] (satisfies? IIndexed v)) +(defn counted? [v] (satisfies? ICounted v)) + + +;; End Type Checks + ;; Range (in-ns :pixie.stdlib.range) @@ -449,6 +680,57 @@ ;; End Range +(in-ns :pixie.stdlib) + + +;; Extend Array + +(extend-type Array + IPersistentCollection + (-conj [arr itm] + (conj (pixie.stdlib.persistent-vector/vector-from-array arr) itm)) + + ICounted + (-count ([arr] + (.-count arr))) + + IReduce + (-reduce [this f init] + (loop [idx 0 + acc init] + (if (reduced? acc) + @acc + (if (< idx (count this)) + (recur (inc idx) + (f acc (aget this idx))) + acc))))) + +(defn array-copy [from from-idx to to-idx size] + (loop [idx 0] + (when (< idx size) + (do (aset to (+ to-idx idx) (aget from (+ from-idx idx))) + (recur (inc idx)))))) + +(defn array-append [arr val] + (let [new-array (make-array (inc (count arr)))] + (array-copy arr 0 new-array 0 (count arr)) + (aset new-array (count arr) val) + new-array)) + +(defn array-clone [arr] + (let [new-array (make-array (count arr))] + (array-copy arr 0 new-array 0 (count arr)) + new-array)) + +(defn array-resize [arr size] + (let [new-array (make-array size)] + (array-copy arr 0 new-array 0 size) + new-array)) + +;;; + + + ;; PersistentVector (in-ns :pixie.stdlib.persistent-vector) @@ -489,6 +771,12 @@ "Index out of range"]))) (deftype PersistentVector [cnt shift root tail meta] + IObject + (-hash [this] + (reduce + pixie.stdlib.hashing/ordered-hashing-rf + this)) + IMessageObject (-get-field [this name] (get-field this name)) @@ -603,7 +891,25 @@ (->TransientVector cnt shift (editable-root root) (editable-tail tail) - meta))) + meta)) + + IReduce + (-reduce [this f init] + ((fn outer-loop [i acc] + (if (< i cnt) + (let [array (array-for this i)] + ((fn inner-loop [i j acc] + (if (< j (count array)) + (let [acc (f acc (aget array j))] + (if (reduced? acc) + @acc + (inner-loop (inc i) + (inc j) + acc))) + (outer-loop i acc))) + i 0 acc)) + acc)) + 0 init))) (defn do-assoc [lvl node idx val] (let [new-array (array-clone (.-array node)) @@ -713,9 +1019,7 @@ (ensure-editable this) (let [trimmed (make-array (- cnt (tail-off self)))] (array-copy tail 0 trimmed 0 (count trimmed)) - (->PersistentVector cnt shift root trimmed))) - -) + (->PersistentVector cnt shift root trimmed)))) (defn editable-root [node] @@ -738,60 +1042,69 @@ (in-ns :pixie.stdlib) -;; Extend Array -(extend-type Array - IPersistentCollection - (-conj [arr itm] - (conj (vector-from-array arr) itm)) + + +;; Extend Core Types + +(extend -invoke Code -invoke) +(extend -invoke NativeFn -invoke) +(extend -invoke VariadicCode -invoke) +(extend -invoke MultiArityFn -invoke) +(extend -invoke Closure -invoke) +(extend -invoke Var -invoke) +(extend -invoke PolymorphicFn -invoke) +(extend -invoke DoublePolymorphicFn -invoke) + +;(extend -reduce Cons seq-reduce) +;(extend -reduce PersistentList seq-reduce) +;(extend -reduce LazySeq seq-reduce) + + + +;(extend -reduce Buffer indexed-reduce) + +(extend -str Bool + (fn [x] + (if x + "true" + "false"))) +(extend -repr Bool -str) + +(extend-type Nil + IObject + (-str [this f] + (f "nil")) + (-repr [this f] + (f "nil")) + (-hash [this] + 1000000) + (-eq [this other] + (identical? this other)) - ICounted - (-count ([arr] - (.-count arr))) + IDeref + (-deref [this] + nil) IReduce (-reduce [this f init] - (loop [idx 0 - acc init] - (if (reduced? acc) - @acc - (if (< idx (count this)) - (recur (inc idx) - (f acc (aget this idx))) - acc))))) + init)) -(defn array-copy [from from-idx to to-idx size] - (loop [idx 0] - (when (< idx size) - (do (aset to (+ to-idx idx) (aget from (+ from-idx idx))) - (recur (inc idx)))))) -(defn array-append [arr val] - (let [new-array (make-array (inc (count arr)))] - (array-copy arr 0 new-array 0 (count arr)) - (aset new-array (count arr) val) - new-array)) +(extend -with-meta Nil (fn [self _] nil)) +(extend -contains-key Nil (fn [_ _] false)) -(defn array-clone [arr] - (let [new-array (make-array (count arr))] - (array-copy arr 0 new-array 0 (count arr)) - new-array)) +(extend -hash Integer pixie.stdlib.hashing/hash-int) -(defn array-resize [arr size] - (let [new-array (make-array size)] - (array-copy arr 0 new-array 0 size) - new-array)) +(extend -eq Integer -num-eq) +(extend -eq Float -num-eq) +(extend -eq Ratio -num-eq) -;;; +;; End Extend Core Types + + +(println (hash (into [] (range 3)))) +;;(println (hash (into [] [1 2 0]))) +(println (type (+ 2 1))) -(def decide (-effect-fn (fn [h k] - (println "Calling.." h) - [(k 41) - (k 42)]))) -(println true) -(-with-handler :foo - (fn [] - - (println (decide :foo)) - )) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 0c08cb00..ebe6930f 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -419,7 +419,8 @@ "Creates a new (empty) environment" [] {:ns 'pixie.stdlib - :vars (atom {'pixie.stdlib {'array true}}) + :vars (atom {'pixie.stdlib {'array true + 'size-t true}}) :tail? true}) diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index f50e11eb..89d4a948 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -73,7 +73,6 @@ (->WriterCache os {})) (defn write-raw-string [os str] - (assert (not= str "nil")) (assert (string? str) "Expected String") (write-int-raw os (count str)) (spit os str false)) @@ -254,7 +253,12 @@ Nil (-write-object [this os] - (write-tag os NIL))) + (write-tag os NIL)) + + Object + (-write-object [this os] + (throw [:pixie.stdlib/IllegalArgumentException + (str "Can't write " this)]))) (defn write-object [os ast] diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index 5648c19d..cdf5a95f 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -2429,3 +2429,23 @@ Calling this function on something that is not ISeqable returns a seq with that (loop* ~(vec (interleave binding-syms binding-syms)) (let ~(vec (interleave bindings binding-syms)) ~@body))))) + + +(defmacro with-handler [[h handler] & body] + `(let [~h ~handler] + (~'pixie.stdlib/-effect-return + ~h + (~'pixie.stdlib/-with-handler + ~h + (fn [] + (~'pixie.stdlib/-effect-val + ~h + (do ~@body))))))) + +(defmacro defeffect + [nm & sigs] + `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) + ~@(map (fn [[x]] + `(def ~x (~'pixie.stdlib/-effect-fn + (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))) + sigs))) diff --git a/pixie/vm2/bits.py b/pixie/vm2/bits.py index 81f8c8d8..7a133ee4 100644 --- a/pixie/vm2/bits.py +++ b/pixie/vm2/bits.py @@ -1,78 +1,98 @@ from pixie.vm2.code import as_var from pixie.vm2.object import affirm -from pixie.vm2.numbers import Integer +from pixie.vm2.numbers import SizeT, Integer from rpython.rlib.rarithmetic import intmask import pixie.vm2.rt as rt +def to_sizet(x): + if isinstance(x, SizeT): + return x + if isinstance(x, Integer): + return SizeT(x.r_uint_val()) + + affirm(False, u"Expected something that can be converted to a SizeT") + @as_var("bit-clear") def bit_clear(x, n): - affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") - return rt.wrap(x.int_val() & ~(1 << n.int_val())) + x = to_sizet(x) + n = to_sizet(n) + return rt.wrap(x.r_uint_val() & ~(1 << n.r_uint_val())) @as_var("bit-set") def bit_set(x, n): - affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") - return rt.wrap(x.int_val() | (1 << n.int_val())) + x = to_sizet(x) + n = to_sizet(n) + return rt.wrap(x.r_uint_val() | (1 << n.r_uint_val())) @as_var("bit-flip") def bit_flip(x, n): - affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") - return rt.wrap(x.int_val() ^ (1 << n.int_val())) + x = to_sizet(x) + n = to_sizet(n) + return rt.wrap(x.r_uint_val() ^ (1 << n.r_uint_val())) @as_var("bit-not") def bit_not(x): - affirm(isinstance(x, Integer), u"x must be an Integer") - return rt.wrap(~x.int_val()) + x = to_sizet(x) + return rt.wrap(~x.r_uint_val()) @as_var("bit-test") def bit_test(x, n): - affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") - return rt.wrap((x.int_val() & (1 << n.int_val())) != 0) + x = to_sizet(x) + n = to_sizet(n) + return rt.wrap((x.r_uint_val() & (1 << n.r_uint_val())) != 0) @as_var("bit-and") def bit_and(x, y): - affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") - return rt.wrap(x.int_val() & y.int_val()) + x = to_sizet(x) + y = to_sizet(y) + return rt.wrap(x.r_uint_val() & y.r_uint_val()) @as_var("bit-and-not") def bit_and_not(x, y): - affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") - return rt.wrap(x.int_val() & ~y.int_val()) + x = to_sizet(x) + y = to_sizet(y) + return rt.wrap(x.r_uint_val() & ~y.r_uint_val()) @as_var("bit-or") def bit_or(x, y): - affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") - return rt.wrap(x.int_val() | y.int_val()) + x = to_sizet(x) + y = to_sizet(y) + return rt.wrap(x.r_uint_val() | y.r_uint_val()) @as_var("bit-xor") def bit_xor(x, y): - affirm(isinstance(x, Integer) and isinstance(y, Integer), u"x and y must be Integers") - return rt.wrap(x.int_val() ^ y.int_val()) + x = to_sizet(x) + y = to_sizet(y) + return rt.wrap(x.r_uint_val() ^ y.r_uint_val()) @as_var("bit-shift-left") def bit_shift_left(x, n): - affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") - return rt.wrap(x.int_val() << n.int_val()) + x = to_sizet(x) + n = to_sizet(n) + return rt.wrap(x.r_uint_val() << n.r_uint_val()) @as_var("bit-shift-right") def bit_shift_right(x, n): - affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") - return rt.wrap(x.int_val() >> n.int_val()) + x = to_sizet(x) + n = to_sizet(n) + affirm(isinstance(x, SizeT) and isinstance(n, SizeT), u"x and n must be of type size-t") + return rt.wrap(x.r_uint_val() >> n.r_uint_val()) @as_var("unsigned-bit-shift-right") def unsigned_bit_shift_right(x, n): - affirm(isinstance(x, Integer) and isinstance(n, Integer), u"x and n must be Integers") - return rt.wrap(intmask(x.r_uint_val() >> n.int_val())) + x = to_sizet(x) + n = to_sizet(n) + return rt.wrap(intmask(x.r_ur_uint_val() >> n.r_uint_val())) digits = "0123456789abcdefghijklmnopqrstuvwxyz" @as_var("bit-str") def bit_str(x, shift): - affirm(isinstance(x, Integer) and isinstance(shift, Integer), u"x and shift must be Integers") - x = x.int_val() - shift = shift.int_val() + x = to_sizet(x) + x = x.r_uint_val() + shift = shift.r_uint_val() buf = ['_'] * 32 char_pos = 32 diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index f344b99d..d9e9953a 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -436,6 +436,11 @@ def invoke_k(self, args, stack): return args[0], stack class EffectFunction(code.BaseCode): + _type = Type(u"pixie.stdlib.EffectFn") + + def type(self): + return EffectFunction._type + def __init__(self, inner_fn): BaseCode.__init__(self) self._inner_fn = inner_fn diff --git a/pixie/vm2/numbers.py b/pixie/vm2/numbers.py index 04c81183..b9c1a822 100644 --- a/pixie/vm2/numbers.py +++ b/pixie/vm2/numbers.py @@ -1,7 +1,7 @@ import pixie.vm2.object as object from pixie.vm2.object import affirm from pixie.vm2.primitives import true, false -from rpython.rlib.rarithmetic import r_uint +from rpython.rlib.rarithmetic import r_uint, intmask from rpython.rlib.rbigint import rbigint import rpython.rlib.jit as jit from pixie.vm2.code import DoublePolymorphicFn, extend, Protocol, as_var, wrap_fn @@ -16,6 +16,8 @@ class Number(object.Object): def type(self): return Number._type + + class Integer(Number): _type = object.Type(u"pixie.stdlib.Integer", Number._type) _immutable_fields_ = ["_int_val"] @@ -38,6 +40,28 @@ def to_str(self): def to_repr(self): return unicode(str(self._int_val)) +class SizeT(Integer): + _type = object.Type(u"pixie.stdlib.SizeT", Integer._type) + _immutable_fields_ = ["_ruint_val"] + + def __init__(self, val): + self._ruint_val = r_uint(val) + + def r_uint_val(self): + return self._ruint_val + + def int_val(self): + return intmask(self._ruint_val) + + def type(self): + return self._type + + def to_str(self): + return unicode(str(self._ruint_val)) + + def to_repr(self): + return unicode(str(self._ruint_val)) + zero_int = Integer(0) one_int = Integer(1) @@ -130,7 +154,7 @@ def extend_num_op(pfn, ty1, ty2, conv1, op, conv2, wrap_start = "rt.wrap(", wrap def define_num_ops(): # maybe define get_val() instead of using tuples? - num_classes = [(Integer, "int_val"), (Float, "float_val")] + num_classes = [(SizeT, "r_uint_val"), (Integer, "int_val"), (Float, "float_val")] for (c1, conv1) in num_classes: for (c2, conv2) in num_classes: for (op, sym) in [("_add", "+"), ("_sub", "-"), ("_mul", "*"), ("_div", "/")]: diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index b4d81659..bf9d3605 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -77,6 +77,7 @@ def set_registry(self, registry): def get_by_name(self, nm, default=None): return self._types.get(nm, default) + _type_registry = TypeRegistry() def get_type_by_name(nm): @@ -109,6 +110,13 @@ def add_subclass(self, tp): def subclasses(self): return self._subclasses + def to_str(self): + return u"" + + def to_repr(self): + return u"" + + Object._type = Type(u"pixie.stdlib.Object", None, False) Type._type = Type(u"pixie.stdlib.Type") diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index 5539f946..4f513b08 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -88,6 +88,8 @@ def wrap(x): return String(unicode(x)) if isinstance(x, Object): return x + if isinstance(x, r_uint): + return numbers.SizeT(x) if x is None: return nil diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 4cef8645..1e838f21 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -1,5 +1,6 @@ import pixie.vm2.rt as rt from pixie.vm2.code import as_var, Var, list_copy, NativeFn +from pixie.vm2.numbers import SizeT from pixie.vm2.object import affirm, Type, runtime_error from pixie.vm2.primitives import nil, true, false import pixie.vm2.code as code @@ -64,6 +65,9 @@ def protocol(name): @as_var("extend") def _extend(proto_fn, tp, fn): + if isinstance(proto_fn, interpreter.EffectFunction): + proto_fn = proto_fn._inner_fn + if not isinstance(proto_fn, code.PolymorphicFn): runtime_error(u"Fist argument to extend should be a PolymorphicFn not a " + proto_fn.type().name()) @@ -182,3 +186,11 @@ def _add_to_string_builder(sb, x): def _finish_string_builder(sb): return rt.wrap(sb.to_str()) +@as_var("size-t") +def size_t(i): + return SizeT(i.int_val()) + + +@as_var("type") +def type(x): + return x.type() \ No newline at end of file From 2f2451f2fb12557744258c8e3cde9dcc0c3acef6 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 9 Jun 2015 00:05:29 -0400 Subject: [PATCH 18/46] more work on PHMs and other stuff --- Makefile | 5 +- pixie/bootstrap.pxi | 267 +++++++++++++++++++++++++++++++++++--- pixie/compiler.pxi | 18 +-- pixie/vm2/bits.py | 22 +++- pixie/vm2/custom_types.py | 25 +++- pixie/vm2/interpreter.py | 10 +- pixie/vm2/keyword.py | 3 + pixie/vm2/numbers.py | 166 ++++++++++++++++-------- pixie/vm2/stdlib.py | 2 +- 9 files changed, 431 insertions(+), 87 deletions(-) diff --git a/Makefile b/Makefile index 1b9bf44b..1edafcbd 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ all: help EXTERNALS=externals -PYTHON ?= python +PYTHON ?= pypy PYTHONPATH=$$PYTHONPATH:$(EXTERNALS)/pypy @@ -29,6 +29,9 @@ build_no_jit: fetch_externals $(PYTHON) $(EXTERNALS)/pypy/rpython/bin/rpython $(COMMON_BUILD_OPTS) target.py make compile_basics +build_no_jit2: fetch_externals + $(PYTHON) $(EXTERNALS)/pypy/rpython/bin/rpython $(COMMON_BUILD_OPTS) target2.py + compile_basics: @echo -e "\n\n\n\nWARNING: Compiling core libs. If you want to modify one of these files delete the .pxic files first\n\n\n\n" ./pixie-vm -c pixie/uv.pxi -c pixie/io.pxi -c pixie/stacklets.pxi -c pixie/stdlib.pxi -c pixie/repl.pxi diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index b52b936e..19ea6655 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -359,7 +359,6 @@ (defn rotl [value shift] (let [value (size-t value) shift (size-t shift)] - (println (type value) (type LONG-BIT) (type shift) (type (- LONG-BIT shift))) (bit-or (bit-shift-right value shift) (bit-shift-left value (- LONG-BIT shift))))) @@ -729,6 +728,33 @@ ;;; +;; Atom + +(defprotocol IAtom + (-swap! [this f args]) + (-reset! [this val])) + +(deftype Atom [value] + IDeref + (-deref [this] + value) + + IAtom + (-swap! [this f args] + (-reset! this (apply f @this args))) + (-reset! [this val] + (set-field! this :value val))) + +(defn atom [init] + (->Atom init)) + +(defn swap! [a f & args] + (-swap! a f args)) + +(defn reset! [a v] + (-reset! a v)) + +;; End Atom ;; PersistentVector @@ -770,12 +796,17 @@ (throw [:pixie.stdlib/IndexOutOfRangeException "Index out of range"]))) -(deftype PersistentVector [cnt shift root tail meta] +(deftype PersistentVector [cnt shift root tail hash-val meta] IObject (-hash [this] - (reduce - pixie.stdlib.hashing/ordered-hashing-rf - this)) + (if hash-val + hash-val + (let [val (reduce + pixie.stdlib.hashing/ordered-hashing-rf + this)] + (set-field! this :hash-val val) + val))) + IMessageObject (-get-field [this name] @@ -787,7 +818,7 @@ (if (< (- cnt (tailoff this)) 32) (let [new-tail (array-append tail val)] - (->PersistentVector (inc cnt) shift root new-tail meta)) + (->PersistentVector (inc cnt) shift root new-tail hash-val meta)) (let [tail-node (->Node (.-edit root) tail)] (if (> (bit-shift-right cnt 5) (bit-shift-left 1 shift)) @@ -800,12 +831,14 @@ (+ shift 5) new-root (array val) + hash-val meta)) (let [new-root (push-tail this shift root tail-node)] (->PersistentVector (inc cnt) shift new-root (array val) + hash-val meta)))))) IIndexed (-nth [self i] @@ -815,7 +848,7 @@ (aget node (bit-and i 0x01F))) (throw [:pixie.stdlib/IndexOutOfRange (str "Index out of range, got " i " only have " cnt)]))) - + (-nth-not-found [self i not-found] (if (and (<= 0 i) (< i cnt)) @@ -846,6 +879,7 @@ shift root new-tail + hash-val meta)) (let [new-tail (array-for this (- cnt 2)) new-root (pop-tail this shift root)] @@ -855,6 +889,7 @@ shift EMPTY-NODE new-tail + hash-val meta) (and (> shift 5) (nil? (aget (.-array new-root) 1))) @@ -862,6 +897,7 @@ (- shift 5) (aget (.-array new-root) 0) new-tail + hash-val meta) :else @@ -869,6 +905,7 @@ shift new-root new-tail + hash-val meta)))))) IAssociative @@ -879,8 +916,8 @@ (if (>= idx (tail-off this)) (let [new-tail (array-clone tail)] (aset new-tail (bit-and idx 0x01f) val) - (->PersistentVector cnt shift root new-tail meta)) - (->PersistentVector cnt shift (do-assoc shift root idx val) tail meta)) + (->PersistentVector cnt shift root new-tail hash-val meta)) + (->PersistentVector cnt shift (do-assoc shift root idx val) tail hash-val meta)) (if (= idx cnt) (-conj this val) (throw [:pixie.stdlib/IndexOutOfRange @@ -971,11 +1008,11 @@ nnode))) -(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil)) +(def EMPTY (->PersistentVector 0 5 EMPTY-NODE (array 0) nil nil)) (defn vector-from-array [arr] (if (< (count arr) 32) - (->PersistentVector (count arr) 5 EMPTY-NODE arr nil) + (->PersistentVector (count arr) 5 EMPTY-NODE arr nil nil) (into [] arr))) @@ -1019,7 +1056,7 @@ (ensure-editable this) (let [trimmed (make-array (- cnt (tail-off self)))] (array-copy tail 0 trimmed 0 (count trimmed)) - (->PersistentVector cnt shift root trimmed)))) + (->PersistentVector cnt shift root trimmed nil meta)))) (defn editable-root [node] @@ -1041,10 +1078,206 @@ ret)) (in-ns :pixie.stdlib) +;; End Persistent Vector +;; Persistent Hash Map +(in-ns :pixie.stdlib.persistent-hash-map) +(defprotocol INode + (-assoc-inode [this shift hash-val key val added-leaf]) + (-find [self shift hash-val key not-found]) + (-reduce-inode [self f init]) + (-without [self shift hash key])) +(defn mask [hash shift] + (bit-and (bit-shift-right hash shift) 0x01f)) + +(defn bitpos [hash shift] + (bit-and (bit-shift-left 1 (mask hash shift)) 0xFFFFFFFF)) + +(defn index [this bit] + (bit-count32 (bit-and (.-bitmap this) + (dec bit)))) + +(deftype BitmapIndexedNode [edit bitmap array] + IMessageObject + (-get-field [this field] + (get-field this field)) + + INode + (-assoc-inode [this shift hash-val key val added-leaf] + (let [bit (bitpos hash-val shift) + idx (index this bit)] + (if (not= (bit-and bitmap bit) 0) + (let [key-or-null (aget array (* 2 idx)) + val-or-node (aget array (inc (* 2 idx)))] + (if (nil? key-or-null) + (let [n (-assoc-inode val-or-node + (+ shift 5) + (bit-and hash-val 0xFFFFFFFF) + key + val + added-leaf)] + (if (identical n val-or-node) + this + (->BitmapIndexedNode nil + bitmap + (clone-and-set array (inc (* 2 idx)) n)))) + (if (= key key-or-null) + (if (identical? val val-or-node) + this + (->BitmapIndexedNode nil + bitmap + (clone-and-set array (inc (* 2 idx)) val))) + (do (reset! added-leaf true) + (->BitmapIndexedNode nil bitmap + (clone-and-set2 array + (* 2 idx) nil + (inc (* 2 idx)) + (create-node (+ shift 5) + key-or-null + val-or-node + hash-val + key + val))))))) + (let [n (bit-count32 bitmap)] + (if (>= n 16) + (let [nodes (make-array 32) + jdx (mask hash-val shift)] + (aset nodes jdx (-assoc-inode BitmapIndexedNode-EMPTY + (+ shift 5) + hash-val + key + val + added-leaf)) + (loop [j 0 + i 0] + (when (< i 32) + (if (not= (bit-and (bit-shift-right bitmap i) 1) 0) + (do (if (nil? (aget array j)) + (aset nodes i (aget array (inc j))) + (aset nodes i (-assoc-inode BitmapIndexedNode-EMPTY + (+ shift 5) + (pixie.stdlib/hash (aget array j)) + (aget array j) + (aget array (inc j)) + added-leaf))) + (recur (+ 2 j) + (inc i))) + (recur j + (inc i))))) + (->ArrayNode nil (inc n) nodes)) + (let [new-array (make-array (* 2 (inc n)))] + (array-copy array 0 new-array 0 (* 2 idx)) + (aset new-array (* 2 idx) key) + (reset! added-leaf true) + (aset new-array (inc (* 2 idx)) val) + (array-copy array (* 2 idx) new-array (* 2 (inc idx)) (* 2 (- n idx))) + (->BitmapIndexedNode nil (bit-or bitmap bit) new-array))))))) + + (-find [self shift has-val key not-found] + (let [bit (bitpos has-val shift)] + (if (= (bit-and bitmap bit) 0) + not-found + (let [idx (index self bit) + key-or-null (aget array (* 2 idx)) + val-or-node (aget array (inc (* 2 idx)))] + (if (nil? key-or-null) + (-find val-or-node (+ 5 shift) hash-val key not-found) + (if (= key key-or-null) + val-or-node + not-found))))))) + +(def BitmapIndexedNode-EMPTY (->BitmapIndexedNode nil (size-t 0) [])) + +(deftype ArrayNode [edit cnt array] + INode + (-assoc-inode [this shift hash-val key val added-leaf] + (let [idx (mask hash-val shift) + node (aget array idx)] + (if (nil? node) + (->ArrayNode nil + (inc cnt) + (clone-and-set array + idx + (-assoc-inode BitmapIndexedNode-EMPTY + (+ shift 5) + hash-val + key + val + added-leaf))) + (let [n (-assoc-inode node + (+ 5 shift) + hash-val + key + val + added-leaf)] + (if (identical? n node) + this + (->ArrayNode nil cnt (clone-and-set array idx n))))))) + (-find [this shift hash-val key not-found] + (let [idx (mask hash-val shift) + node (aget array idx)] + (if (nil? node) + not-found + (-find node + (+ shift 5) + hash-val + key + not-found))))) + +(deftype PersistentHashMap [cnt root has-nil? nil-val meta] + IAssociative + (-assoc [this key val] + (if (nil? key) + (if (identical? val nil-val) + this + (->PersistentHashMap cnt root true key)) + (let [new-root (if (nil? root) + BitmapIndexedNode-EMPTY + root) + added-leaf (atom false) + new-root (-assoc-inode new-root + 0 + (bit-and (hash key) 0xFFFFFFFF) + key + val + added-leaf)] + (if (identical? new-root root) + this + (->PersistentHashMap (if @added-leaf + (inc cnt) + cnt) + new-root + has-nil? + nil-val + meta)))))) + +(def EMPTY (->PersistentHashMap (size-t 0) nil false nil nil)) + +(defn create-node [shift key1 val1 key2hash key2 val2] + (let [key1hash (bit-and (pixie.stdlib/hash key1) 0xFFFFFFFF)] + (if (= key1hash key2hash) + (->HashCollisionNode nil key1hash [key1 val1 key2 val2]) + (let [added-leaf (atom false)] + (-> BitmapIndexedNode-EMPTY + (-assoc-inode shift key1hash key1 val1 added-leaf) + (-assoc-inode shift key2hash key2 val2 added-leaf)))))) + +(defn clone-and-set [array i a] + (let [clone (array-clone array)] + (aset array i a) + clone)) + +(defn clone-and-set2 [array i a j b] + (let [clone (array-clone array)] + (aset clone i a) + (aset clone j b) + clone)) + +(in-ns :pixie.stdlib) +;; End Persistent Hash Map ;; Extend Core Types (extend -invoke Code -invoke) @@ -1103,8 +1336,8 @@ ;; End Extend Core Types -(println (hash (into [] (range 3)))) -;;(println (hash (into [] [1 2 0]))) - -(println (type (+ 2 1))) - +(reduce + (fn [acc x] + (-assoc acc x x)) + pixie.stdlib.persistent-hash-map/EMPTY + (range 100)) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index ebe6930f..47fabb90 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -102,13 +102,14 @@ (defmethod analyze-seq 'do [x] - {:op :do - :children '[:statements :ret] - :env *env* - :form x - :statements (binding [*env* (assoc *env* :tail? false)] - (mapv analyze-form (butlast (next x)))) - :ret (analyze-form (last x))}) + (let [statement-asts (binding [*env* (assoc *env* :tail? false)] + (mapv analyze-form (butlast (next x))))] + {:op :do + :children '[:statements :ret] + :env *env* + :form x + :statements statement-asts + :ret (analyze-form (last x))})) (defmethod analyze-seq 'comment [x] @@ -420,7 +421,8 @@ [] {:ns 'pixie.stdlib :vars (atom {'pixie.stdlib {'array true - 'size-t true}}) + 'size-t true + 'bit-count32 true}}) :tail? true}) diff --git a/pixie/vm2/bits.py b/pixie/vm2/bits.py index 7a133ee4..0d7f63ec 100644 --- a/pixie/vm2/bits.py +++ b/pixie/vm2/bits.py @@ -2,7 +2,7 @@ from pixie.vm2.object import affirm from pixie.vm2.numbers import SizeT, Integer -from rpython.rlib.rarithmetic import intmask +from rpython.rlib.rarithmetic import intmask, r_uint import pixie.vm2.rt as rt @@ -10,27 +10,35 @@ def to_sizet(x): if isinstance(x, SizeT): return x if isinstance(x, Integer): - return SizeT(x.r_uint_val()) + return SizeT(r_uint(x.r_uint_val())) affirm(False, u"Expected something that can be converted to a SizeT") +@as_var("bit-count32") +def bit_count(i): + i = to_sizet(i).r_uint_val() + i = i - ((i >> 1) & r_uint(0x55555555)) + i = (i & r_uint(0x33333333)) + ((i >> 2) & r_uint(0x33333333)) + return SizeT((((i + (i >> 4) & r_uint(0xF0F0F0F)) * r_uint(0x1010101)) & r_uint(0xffffffff)) >> 24) + + @as_var("bit-clear") def bit_clear(x, n): x = to_sizet(x) n = to_sizet(n) - return rt.wrap(x.r_uint_val() & ~(1 << n.r_uint_val())) + return rt.wrap(x.r_uint_val() & ~(r_uint(1) << n.r_uint_val())) @as_var("bit-set") def bit_set(x, n): x = to_sizet(x) n = to_sizet(n) - return rt.wrap(x.r_uint_val() | (1 << n.r_uint_val())) + return rt.wrap(x.r_uint_val() | (r_uint(1) << n.r_uint_val())) @as_var("bit-flip") def bit_flip(x, n): x = to_sizet(x) n = to_sizet(n) - return rt.wrap(x.r_uint_val() ^ (1 << n.r_uint_val())) + return rt.wrap(x.r_uint_val() ^ (r_uint(1) << n.r_uint_val())) @as_var("bit-not") def bit_not(x): @@ -41,7 +49,7 @@ def bit_not(x): def bit_test(x, n): x = to_sizet(x) n = to_sizet(n) - return rt.wrap((x.r_uint_val() & (1 << n.r_uint_val())) != 0) + return rt.wrap((x.r_uint_val() & (r_uint(1) << n.r_uint_val())) != r_uint(0)) @as_var("bit-and") def bit_and(x, y): @@ -84,7 +92,7 @@ def bit_shift_right(x, n): def unsigned_bit_shift_right(x, n): x = to_sizet(x) n = to_sizet(n) - return rt.wrap(intmask(x.r_ur_uint_val() >> n.r_uint_val())) + return rt.wrap(intmask(x.r_uint_val() >> n.r_uint_val())) digits = "0123456789abcdefghijklmnopqrstuvwxyz" diff --git a/pixie/vm2/custom_types.py b/pixie/vm2/custom_types.py index 0a6e0434..02149afc 100644 --- a/pixie/vm2/custom_types.py +++ b/pixie/vm2/custom_types.py @@ -3,13 +3,29 @@ from rpython.rlib.rarithmetic import r_uint from pixie.vm2.code import as_var from pixie.vm2.numbers import Integer, Float -from pixie.vm2.keyword import Keyword +from pixie.vm2.keyword import Keyword, keyword from pixie.vm2.array import Array import pixie.vm2.rt as rt MAX_FIELDS = 32 +def make_ctor_fn(type_name, field_names): + """Constructs a function that will contsruct a Custom type with the given type name + and field names. The resulting function should be called with a list of Objects.""" + + slots = {} + for idx, val in enumerate(field_names): + slots[keyword(val)] = idx + + type = CustomType(type_name, slots) + + def ctor(itms): + return new_inst(type, itms) + + return ctor + + class CustomType(Type): _immutable_fields_ = ["_slots", "_rev?"] def __init__(self, name, slots): @@ -144,6 +160,12 @@ def set_field_by_idx(self, idx, val): self._custom_field{c} = val """ +get_list_template = """ + def get_list(self): + return {d} + +""" + def gen_ct_class_code(): acc = "" for x in range(MAX_FIELDS + 1): @@ -162,6 +184,7 @@ def gen_ct_class_code(): for y in range(x): acc += set_field_by_idx_template.format(c=y) + acc += get_list_template.format(d="[" + ", ".join(map(lambda x: "self._custom_field" + str(x), range(x))) + "]") #print acc diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index d9e9953a..319f332e 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -6,6 +6,7 @@ from pixie.vm2.code import BaseCode import rpython.rlib.jit as jit +from pixie.vm2.debugger import expose class AST(Object): _immutable_fields_ = ["_c_meta"] @@ -57,6 +58,7 @@ class PrevASTNil(AST): def __init__(self): AST.__init__(self, nil) +@expose("_c_ast", "_c_locals") class InterpretK(Continuation): _immutable_ = True def __init__(self, ast, locals): @@ -70,6 +72,7 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast +@expose("_c_val") class Const(AST): _immutable_fields_ = ["_c_val"] _type = Type(u"pixie.interpreter.Const") @@ -80,6 +83,7 @@ def __init__(self, val, meta=nil): def interpret(self, _, locals, stack): return self._c_val, stack +@expose("_c_value", "_c_name", "_c_next") class Locals(object): _immutable_ = True def __init__(self, name, value, next): @@ -334,6 +338,7 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast +@expose("_c_var") class VDeref(AST): _immutable_fields_ = ["_c_var"] def __init__(self, var, meta=nil): @@ -351,7 +356,7 @@ def get_printable_location(ast): jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) -def run_stack(val, cont, stack=None): +def run_stack(val, cont, stack=None, enter_debug=True): stack = None val = None ast = cont.get_ast() @@ -361,6 +366,9 @@ def run_stack(val, cont, stack=None): val, stack = cont.call_continuation(val, stack) ast = cont.get_ast() except BaseException as ex: + if enter_debug: + from pixie.vm2.debugger import debug + #debug(cont, stack, val) print_stacktrace(cont, stack) if not we_are_translated(): print ex diff --git a/pixie/vm2/keyword.py b/pixie/vm2/keyword.py index 74778798..469315bc 100644 --- a/pixie/vm2/keyword.py +++ b/pixie/vm2/keyword.py @@ -32,6 +32,9 @@ def init_names(self): self._w_ns = rt.wrap(s[0]) self._w_name = rt.wrap(u"/".join(s[1:])) + def __repr__(self): + return u":" + self._str + class KeywordCache(object): def __init__(self): diff --git a/pixie/vm2/numbers.py b/pixie/vm2/numbers.py index b9c1a822..31227e7d 100644 --- a/pixie/vm2/numbers.py +++ b/pixie/vm2/numbers.py @@ -4,7 +4,7 @@ from rpython.rlib.rarithmetic import r_uint, intmask from rpython.rlib.rbigint import rbigint import rpython.rlib.jit as jit -from pixie.vm2.code import DoublePolymorphicFn, extend, Protocol, as_var, wrap_fn +from pixie.vm2.code import DoublePolymorphicFn, extend, Protocol, as_var, wrap_fn, munge #from pixie.vm.libs.pxic.util import add_marshall_handlers import pixie.vm2.rt as rt @@ -137,59 +137,123 @@ def ratio_read(obj): #as_var("MAX-NUMBER")(Integer(100000)) # TODO: set this to a real max number -num_op_template = """@extend({pfn}, {ty1}._type, {ty2}._type) -def {pfn}_{ty1}_{ty2}(a, b): - assert isinstance(a, {ty1}) and isinstance(b, {ty2}) - return {wrap_start}a.{conv1}() {op} b.{conv2}(){wrap_end} +# Ordering of conversions. If a given function is called with two numbers of different +# types, then the type lower on this list will always be upconverted before the opration is +# performed. + +number_orderings = [Integer, SizeT, BigInteger, Float] + +# Given a value of a certain type, how do we convert it to the *primitive* of another type? +# Notice that conversions for a type to itself must exist, this is then the simple upwrap case. +conversion_templates = {Integer: {Integer: "{x}.int_val()", + SizeT: "{x}.r_uint_val()", + Float: "float({x}.int_val())", + BigInteger: "rbigint.fromint({x}.int_val())"}, + SizeT: {SizeT:"{x}.r_uint_val()", + Float:"float({x}.int_val())", + BigInteger:"rbigint.fromint({x}.int_val())"}, + BigInteger: {BigInteger: "{x}.bigint_val()", + Float: "{x}.bigint_val().tofloat()"}, + Float: {Float: "{x}.float_val()"}} + +# Given an operation and a type, how do we perform that operation? + +operations = {"-add": {Integer: "{x} + {y}", + SizeT: "{x} + {y}", + BigInteger: "{x}.add({y})", + Float: "{x} + {y}"}, + "-sub": {Integer: "{x} - {y}", + SizeT: "{x} - {y}", + BigInteger: "{x}.sub({y})", + Float: "{x} - {y}"}, + "-mul": {Integer: "{x} * {y}", + SizeT: "{x} * {y}", + BigInteger: "{x}.mul({y})", + Float: "{x} * {y}"}, + "-div": {Integer: "{x} / {y}", + SizeT: "{x} / {y}", + BigInteger: "{x}.div({y})", + Float: "{x} / {y}"}, + "-gt": {Integer: "{x} > {y}", + SizeT: "{x} > {y}", + BigInteger: "{x}.gt({y})", + Float: "{x} > {y}"}, + + "-lt": {Integer: "{x} < {y}", + SizeT: "{x} < {y}", + BigInteger: "{x}.lt({y})", + Float: "{x} < {y}"}, + + "-gte": {Integer: "{x} >= {y}", + SizeT: "{x} >= {y}", + BigInteger: "{x}.ge({y})", + Float: "{x} >= {y}"}, + + "-lte": {Integer: "{x} <= {y}", + SizeT: "{x} <= {y}", + BigInteger: "{x}.le({y})", + Float: "{x} <= {y}"}, + + "-num-eq": {Integer: "{x} == {y}", + SizeT: "{x} == {y}", + BigInteger: "{x}.eq({y})", + Float: "{x} == {y}"}, + } + +# These functions return bool and so should always be returned via rt.wrap +binop_names = {"-gt", "-lt", "-gte", "-lte", "-num-eq"} + +# How do we wrap primitives? +wrappers = {Integer: "rt.wrap({x})", + SizeT: "SizeT({x})", + BigInteger: "rt.wrap({x})", + Float: "rt.wrap({x})"} + + + +op_template = """ +@extend({pfn}, {t1}._type, {t2}._type) +def {pfn}_{t1}_{t2}(x, y): + return {result} """ -def extend_num_op(pfn, ty1, ty2, conv1, op, conv2, wrap_start = "rt.wrap(", wrap_end = ")"): - tp = num_op_template.format(pfn=pfn, ty1=ty1.__name__, ty2=ty2.__name__, - conv1=conv1, op=op, conv2=conv2, - wrap_start=wrap_start, wrap_end=wrap_end) - exec tp - -extend_num_op("_quot", Integer, Integer, "int_val", "/", "int_val") -extend_num_op("_rem", Integer, Integer, "int_val", "%", "int_val") - -def define_num_ops(): - # maybe define get_val() instead of using tuples? - num_classes = [(SizeT, "r_uint_val"), (Integer, "int_val"), (Float, "float_val")] - for (c1, conv1) in num_classes: - for (c2, conv2) in num_classes: - for (op, sym) in [("_add", "+"), ("_sub", "-"), ("_mul", "*"), ("_div", "/")]: - if op == "_div" and c1 == Integer and c2 == Integer: - continue - extend_num_op(op, c1, c2, conv1, sym, conv2) - if c1 != Integer or c2 != Integer: - extend_num_op("_rem", c1, c2, conv1, ",", conv2, wrap_start = "rt.wrap(math.fmod(", wrap_end = "))") - extend_num_op("_quot", c1, c2, conv1, "/", conv2, wrap_start = "rt.wrap(math.floor(", wrap_end = "))") - for (op, sym) in [("_num_eq", "=="), ("_lt", "<"), ("_gt", ">"), ("_lte", "<="), ("_gte", ">=")]: - extend_num_op(op, c1, c2, conv1, sym, conv2, - wrap_start = "true if ", wrap_end = " else false") - -define_num_ops() - -bigint_ops_tmpl = """@extend({pfn}, {ty1}._type, {ty2}._type) -def _{pfn}_{ty1}_{ty2}(a, b): - assert isinstance(a, {ty1}) and isinstance(b, {ty2}) - return rt.wrap({conv1}(a.{get1}()).{op}({conv2}(b.{get2}()))) -""" +def get_rank(t1): + for idx, tp in enumerate(number_orderings): + if tp == t1: + return idx + + assert False, str(t1) + " not found" + + +def make_num_op(pfn, t1, t2): + t1rank = get_rank(t1) + t2rank = get_rank(t2) + + if t1rank >= t2rank: + t1_conv = t1 + t2_conv = t1 + else: + t1_conv = t2 + t2_conv = t2 + + wrapper = wrappers[t1_conv] if pfn not in binop_names else "rt.wrap({x})" + + result = wrapper.format(x=operations[pfn][t1_conv].format(x=conversion_templates[t1][t1_conv].format(x="x"), + y=conversion_templates[t2][t2_conv].format(x="y"))) + + templated = op_template.format(pfn=munge(pfn), + t1=str(t1._type._name.split(".")[-1]), + t2=str(t2._type._name.split(".")[-1]), + result=result) + + return templated + +for pfn in operations: + for t1 in number_orderings: + for t2 in number_orderings: + exec make_num_op(pfn, t1, t2) + -def define_bigint_ops(): - num_classes = [(Integer, "rbigint.fromint", "int_val"), (BigInteger, "", "bigint_val")] - for (c1, conv1, get1) in num_classes: - for (c2, conv2, get2) in num_classes: - if c1 == Integer and c2 == Integer: - continue - for (pfn, op) in [("_add", "add"), ("_sub", "sub"), ("_mul", "mul"), ("_div", "div"), - ("_num_eq", "eq"), ("_lt", "lt"), ("_gt", "gt"), ("_lte", "le"), ("_gte", "ge")]: - code = bigint_ops_tmpl.format(pfn=pfn, op=op, - ty1=c1.__name__, conv1=conv1, get1=get1, - ty2=c2.__name__, conv2=conv2, get2=get2) - exec code - -define_bigint_ops() def gcd(u, v): while v != 0: diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 1e838f21..3ba1482f 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -188,7 +188,7 @@ def _finish_string_builder(sb): @as_var("size-t") def size_t(i): - return SizeT(i.int_val()) + return SizeT(i.r_uint_val()) @as_var("type") From 3b9689925d50a43451334a511346ac0f25dddd5b Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Wed, 10 Jun 2015 21:02:25 -0400 Subject: [PATCH 19/46] implemented some of PHMs and debugged --- pixie/bootstrap.pxi | 147 +++++++++++++++++++++++++++++++++++++------- pixie/compiler.pxi | 1 + 2 files changed, 125 insertions(+), 23 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 19ea6655..cfdffba1 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -756,6 +756,36 @@ ;; End Atom +;; Map Entry + + + +(deftype MapEntry [k v meta] + IMapEntry + (-key [this] + k) + (-val [this] + v) + + IIndexed + (-nth [this idx] + (cond + (= idx 0) k + (= idx 1) v + :else (throw [:pixie.stdlib/IndexError + "Index out of Range"]))) + + (-nth-not-found [this idx not-found] + (cond + (= idx 0) k + (= idx 1) v + :else not-found))) + +(defn map-entry [k v] + (->MapEntry k v nil)) + +;; End Map Entry + ;; PersistentVector @@ -1084,6 +1114,9 @@ (in-ns :pixie.stdlib.persistent-hash-map) +(def MASK-32 0xFFFFFFFF) + + (defprotocol INode (-assoc-inode [this shift hash-val key val added-leaf]) (-find [self shift hash-val key not-found]) @@ -1094,12 +1127,13 @@ (bit-and (bit-shift-right hash shift) 0x01f)) (defn bitpos [hash shift] - (bit-and (bit-shift-left 1 (mask hash shift)) 0xFFFFFFFF)) + (bit-and (bit-shift-left 1 (mask hash shift)) MASK-32)) (defn index [this bit] (bit-count32 (bit-and (.-bitmap this) (dec bit)))) + (deftype BitmapIndexedNode [edit bitmap array] IMessageObject (-get-field [this field] @@ -1115,7 +1149,7 @@ (if (nil? key-or-null) (let [n (-assoc-inode val-or-node (+ shift 5) - (bit-and hash-val 0xFFFFFFFF) + (bit-and hash-val MASK-32) key val added-leaf)] @@ -1176,8 +1210,8 @@ (array-copy array (* 2 idx) new-array (* 2 (inc idx)) (* 2 (- n idx))) (->BitmapIndexedNode nil (bit-or bitmap bit) new-array))))))) - (-find [self shift has-val key not-found] - (let [bit (bitpos has-val shift)] + (-find [self shift hash-val key not-found] + (let [bit (bitpos hash-val shift)] (if (= (bit-and bitmap bit) 0) not-found (let [idx (index self bit) @@ -1187,10 +1221,29 @@ (-find val-or-node (+ 5 shift) hash-val key not-found) (if (= key key-or-null) val-or-node - not-found))))))) + not-found)))))) + + (-reduce-inode [this f init] + (loop [x 0 + acc init] + (if (< x (count array)) + (let [key-or-nil (aget array x) + val-or-node (aget array (inc x)) + acc (if (and (nil? key-or-nil) + (not (nil? val-or-node))) + (-reduce-inode val-or-node f acc) + (f acc (map-entry key-or-nil val-or-node)))] + (if (reduced? acc) + acc + (recur (+ 2 x) acc))) + acc)))) (def BitmapIndexedNode-EMPTY (->BitmapIndexedNode nil (size-t 0) [])) +(defn ann [x] + (assert x) + x) + (deftype ArrayNode [edit cnt array] INode (-assoc-inode [this shift hash-val key val added-leaf] @@ -1208,11 +1261,11 @@ val added-leaf))) (let [n (-assoc-inode node - (+ 5 shift) - hash-val - key - val - added-leaf)] + (+ 5 shift) + hash-val + key + val + added-leaf)] (if (identical? n node) this (->ArrayNode nil cnt (clone-and-set array idx n))))))) @@ -1225,7 +1278,20 @@ (+ shift 5) hash-val key - not-found))))) + not-found)))) + + (-reduce-inode [this f init] + (loop [x 0 + acc init] + (if (< x (count array)) + (let [node (aget array x)] + (if (not (nil? node)) + (let [acc (-reduce-inode node f acc)] + (if (reduced? acc) + acc + (recur (inc x) acc))) + (recur (inc x) acc))) + acc)))) (deftype PersistentHashMap [cnt root has-nil? nil-val meta] IAssociative @@ -1240,7 +1306,7 @@ added-leaf (atom false) new-root (-assoc-inode new-root 0 - (bit-and (hash key) 0xFFFFFFFF) + (bit-and (hash key) MASK-32) key val added-leaf)] @@ -1252,12 +1318,39 @@ new-root has-nil? nil-val - meta)))))) + meta))))) + + ILookup + (-get [this key not-found] + (if (nil? key) + (if has-nil? + nil-val + not-found) + (if (nil? root) + not-found + (-find root 0 + (bit-and (hash key) MASK-32) + key + not-found)))) + + IReduce + (-reduce [this f init] + (let [acc (if has-nil? + (f init nil-val) + init)] + (if (reduced? acc) + @acc + (if root + (let [acc (-reduce-inode root f acc)] + (if (reduced? acc) + @acc + acc)) + acc))))) (def EMPTY (->PersistentHashMap (size-t 0) nil false nil nil)) (defn create-node [shift key1 val1 key2hash key2 val2] - (let [key1hash (bit-and (pixie.stdlib/hash key1) 0xFFFFFFFF)] + (let [key1hash (bit-and (pixie.stdlib/hash key1) MASK-32)] (if (= key1hash key2hash) (->HashCollisionNode nil key1hash [key1 val1 key2 val2]) (let [added-leaf (atom false)] @@ -1267,7 +1360,7 @@ (defn clone-and-set [array i a] (let [clone (array-clone array)] - (aset array i a) + (aset clone i a) clone)) (defn clone-and-set2 [array i a j b] @@ -1298,10 +1391,10 @@ ;(extend -reduce Buffer indexed-reduce) (extend -str Bool - (fn [x] + (fn [x sb] (if x - "true" - "false"))) + (sb "true") + (sb "false")))) (extend -repr Bool -str) (extend-type Nil @@ -1336,8 +1429,16 @@ ;; End Extend Core Types -(reduce - (fn [acc x] - (-assoc acc x x)) - pixie.stdlib.persistent-hash-map/EMPTY - (range 100)) +(println (reduce + (fn [acc [k v]] + (+ acc v)) + 0 + (reduce + (fn [acc x] + (-assoc acc x x)) + pixie.stdlib.persistent-hash-map/EMPTY + (range 100))) + (reduce + + + (range 100))) + diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 47fabb90..fa2ded16 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -235,6 +235,7 @@ (defmethod analyze-seq 'recur [[_ & args]] + (analyze-form `(~'__loop__fn__ ~@args))) (defmethod analyze-seq 'def From caebca52240a0a7782970cc4e0d4f40ad928a462 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Thu, 11 Jun 2015 19:45:32 -0400 Subject: [PATCH 20/46] a bunch more work on stuff, and a ton of debugging --- pixie/bootstrap.pxi | 185 ++++++++++++++++++++++++++++--- pixie/compiler.pxi | 122 ++++++++++++++------- pixie/pxic-writer.pxi | 9 +- pixie/vm2/jit_tables.py | 67 ++++++++++++ pixie/vm2/pxic_reader.py | 228 +++++++++++++++++++++++++++++++++++++++ pixie/vm2/rt.py | 1 + pixie/vm2/string.py | 55 +++++++--- target2.py | 8 +- 8 files changed, 607 insertions(+), 68 deletions(-) create mode 100644 pixie/vm2/jit_tables.py create mode 100644 pixie/vm2/pxic_reader.py diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index cfdffba1..a09c8bc6 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -289,6 +289,52 @@ (defn count ([coll] (-count coll))) +(defn assoc + {:doc "Associates the key with the value in the collection" + :signatures [[m] [m k v] [m k v & kvs]] + :added "0.1"} + ([m] m) + ([m k v] + (-assoc m k v)) + ([m k v & rest] + (apply assoc (-assoc m k v) rest))) + +(defn key [m] + (-key m)) + +(defn val [m] + (-val m)) + +(defn apply [f & args] + (let [last-itm (last args) + but-last-cnt (dec (count args)) + arg-array (make-array (+ but-last-cnt + (count last-itm))) + _ (array-copy args 0 arg-array 0 but-last-cnt) + idx (reduce + (fn [idx itm] + (aset arg-array idx itm) + (inc idx)) + but-last-cnt + last-itm)] + (-apply f arg-array))) + +(defn last [coll] + (println "LAST " (type coll)) + (if (vector? coll) + (nth coll (dec (count coll))) + (loop [coll coll] + (if-let [v (next coll)] + v + (first coll))))) + +(defn butlast [coll] + (loop [res [] + coll coll] + (if (next coll) + (recur (conj res (first coll)) + (next coll)) + (seq res)))) (deftype Cons [first next meta] ISeq @@ -604,6 +650,7 @@ (defn indexed? [v] (satisfies? IIndexed v)) (defn counted? [v] (satisfies? ICounted v)) +(defn vector? [v] (satisfies? IVector v)) ;; End Type Checks @@ -684,10 +731,25 @@ ;; Extend Array +(satisfy IVector Array) + (extend-type Array IPersistentCollection (-conj [arr itm] (conj (pixie.stdlib.persistent-vector/vector-from-array arr) itm)) + + IIndexed + (-nth [this idx] + (if (and (<= 0 idx) + (< idx (count this))) + (aget this idx) + (throw [:pixie.stdlib/IndexOutOfRangeException + "Index out of range"]))) + (-nth-not-found [this idx not-found] + (if (and (<= 0 idx) + (< idx (count this))) + (aget this idx) + not-found)) ICounted (-count ([arr] @@ -1293,13 +1355,51 @@ (recur (inc x) acc))) acc)))) -(deftype PersistentHashMap [cnt root has-nil? nil-val meta] +(deftype PersistentHashMap [cnt root has-nil? nil-val hash-val meta] + IObject + (-hash [this] + (if hash-val + hash-val + (do (set-field! this :hash-val + (transduce cat + pixie.stdlib.hashing/unordered-hash-reducing-fn + this)) + hash-val))) + + (-str [this sb] + (sb "{") + (let [not-first (atom false)] + (reduce + (fn [_ x] + (if @not-first + (sb " ") + (reset! not-first true)) + (-str (key x) sb) + (sb " ") + (-str (val x) sb)) + nil + this)) + (sb "}")) + + IMeta + (-meta [this] + meta) + + IWithMeta + (-with-meta [this new-meta] + (->PersistentHashMap cnt root has-nil? nil-val hash-val new-meta)) + + IEmpty + (-empty [this] + (-with-meta pixie.stdlib.persistent-hash-map/EMPTY + meta)) + IAssociative (-assoc [this key val] (if (nil? key) (if (identical? val nil-val) this - (->PersistentHashMap cnt root true key)) + (->PersistentHashMap cnt root true val nil meta)) (let [new-root (if (nil? root) BitmapIndexedNode-EMPTY root) @@ -1318,6 +1418,7 @@ new-root has-nil? nil-val + nil meta))))) ILookup @@ -1347,7 +1448,7 @@ acc)) acc))))) -(def EMPTY (->PersistentHashMap (size-t 0) nil false nil nil)) +(def EMPTY (->PersistentHashMap (size-t 0) nil false nil nil nil)) (defn create-node [shift key1 val1 key2hash key2 val2] (let [key1hash (bit-and (pixie.stdlib/hash key1) MASK-32)] @@ -1370,6 +1471,16 @@ clone)) (in-ns :pixie.stdlib) + +(defn hashmap [& args] + (loop [idx 0 + acc pixie.stdlib.persistent-hash-map/EMPTY] + (if (< idx (count args)) + (do (assert (> (- (count args) idx) 1) "hashmap requires even number of args") + (recur (+ 2 idx) + (assoc acc (nth args idx) (nth args (inc idx))))) + acc))) + ;; End Persistent Hash Map ;; Extend Core Types @@ -1429,16 +1540,60 @@ ;; End Extend Core Types -(println (reduce - (fn [acc [k v]] - (+ acc v)) - 0 - (reduce - (fn [acc x] - (-assoc acc x x)) - pixie.stdlib.persistent-hash-map/EMPTY - (range 100))) - (reduce - + - (range 100))) +;; Multimethod stuff +#_(comment + + +(deftype MultiMethod [name dispatch-fn default-val methods] + IFn + (-invoke [self & args] + (let [dispatch-val (apply dispatch-fn args) + method (if (contains? @methods dispatch-val) + (get @methods dispatch-val) + (get @methods default-val)) + _ (assert method (str "no method defined for " dispatch-val " on " name))] + (try + (apply method args) + (catch ex + (throw (add-exception-info ex (str "In multimethod " + name + " dispatching on " + dispatch-val + "\n") args))))))) + +(defmacro defmulti + {:doc "Define a multimethod, which dispatches to its methods based on dispatch-fn." + :examples [["(defmulti greet first)"] + ["(defmethod greet :hi [[_ name]] (str \"Hi, \" name \"!\"))"] + ["(defmethod greet :hello [[_ name]] (str \"Hello, \" name \".\"))"] + ["(greet [:hi \"Jane\"])" nil "Hi, Jane!"]] + :signatures [[name dispatch-fn & options]] + :added "0.1"} + [name & args] + (let [[meta args] (if (string? (first args)) + [{:doc (first args)} (next args)] + [{} args]) + [meta args] (if (map? (first args)) + [(merge meta (first args)) (next args)] + [meta args]) + dispatch-fn (first args) + options (apply hashmap (next args))] + `(def ~name (->MultiMethod ~(str name) ~dispatch-fn ~(get options :default :default) (atom {}))))) + +(defmacro defmethod + {:doc "Define a method of a multimethod. See `(doc defmulti)` for details." + :signatures [[name dispatch-val [param*] & body]] + :added "0.1"} + [name dispatch-val params & body] + `(do + (let [methods (.methods ~name)] + (swap! methods + assoc + ~dispatch-val (fn ~params + ~@body)) + ~name))) +) + +;; End Multimethods + diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index fa2ded16..8def7f47 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -89,6 +89,7 @@ (symbol? x) :symbol (number? x) :number (string? x) :string + (char? x) :char (keyword? x) :keyword))) (defmulti analyze-seq (fn [x] @@ -235,7 +236,7 @@ (defmethod analyze-seq 'recur [[_ & args]] - + () (analyze-form `(~'__loop__fn__ ~@args))) (defmethod analyze-seq 'def @@ -350,6 +351,13 @@ :form x :env *env*}) +(defmethod analyze-form :char + [x] + {:op :const + :type :char + :form x + :env *env*}) + (defmethod analyze-form :seq [x] (analyze-seq x)) @@ -423,7 +431,9 @@ {:ns 'pixie.stdlib :vars (atom {'pixie.stdlib {'array true 'size-t true - 'bit-count32 true}}) + 'bit-count32 true + 'contains-table true + 'switch-table true}}) :tail? true}) @@ -431,25 +441,28 @@ ([form] (analyze form (new-env))) ([form env] - (binding [*env* env] - (analyze-form form)))) + (if *env* + (analyze-form form) + (binding [*env* env] + (analyze-form form))))) (defn walk [pre post selector node] - (-> (reduce - (fn [node k] - (let [v (get node k) - result (if (or (vector? v) - (seq? v)) - (mapv (partial walk pre post selector) v) - (walk pre post selector v))] - (assoc node k result))) - (pre node) - (selector node)) - post)) + (let [walk-fn (partial walk pre post selector)] + (-> (reduce + (fn [node k] + (let [v (get node k) + result (if (or (vector? v) + (seq? v)) + (mapv walk-fn v) + (walk-fn v))] + (assoc node k result))) + (pre node) + (selector node)) + post))) (defn post-walk [f ast] (walk identity f :children ast)) @@ -592,27 +605,64 @@ (defn run-passes [ast] (walk identity (comp - convert-vectors - convert-fns - (comp convert-defs - collect-closed-overs - clean-do)) + persistent! + (comp convert-vectors + convert-fns + (comp convert-defs + collect-closed-overs + (comp clean-do + #_transient)))) :children ast)) - -(println "Reading") -(let [form (time (read-string (str "(do " (pixie.io/slurp "pixie/bootstrap.pxi") ")"))) - _ (println "Compiling") - ast (time (analyze form)) - _ (println "Passes") - ast (time (run-passes ast)) - _ (println "To String") - os (-> "/tmp/bootstrap.pxic" - io/open-write - io/buffered-output-stream)] - (binding [pxic-writer/*cache* (pxic-writer/writer-cache os)] - (time (pxic-writer/write-object os ast))) - #_(print str) - (dispose! os) - (println "done")) +(defn read-and-compile [form env] + (let [ast (analyze form env) + ast (run-passes ast)] + ast)) + +#_(defn compile-file [from to] + (println "Reading") + (let [form (time (read-string (str "(do " (pixie.io/slurp from) ")"))) + _ (println "Compiling") + ast (time (analyze form)) + _ (println "Passes") + ast (time (run-passes ast)) + _ (println "To String") + os (-> to + io/open-write + io/buffered-output-stream)] + (binding [pxic-writer/*cache* (pxic-writer/writer-cache os)] + (time (pxic-writer/write-object os ast))) + #_(print str) + (dispose! os) + (println "done"))) + +(defn compile-file [from os] + (let [forms (read-string (str "[" (io/slurp from) "]")) + form-count (atom 0) + total-count (atom 0)] + (doseq [form forms] + (swap! form-count inc) + (swap! total-count inc) + (when (= @form-count 10) + (println from (int (* 100 (/ @total-count (count forms)))) "% in" (:ns *env*)) + (reset! form-count 0)) + + (let [ast (read-and-compile form env)] + (pxic-writer/write-object os ast))))) + +(defn compile-files [files to] + (let [os (-> to + io/open-write + io/buffered-output-stream) + env (new-env) +] + (binding [*env* env] + (binding [pxic-writer/*cache* (pxic-writer/writer-cache os)] + (doseq [file files] + (compile-file file os)))) + (dispose! os))) + +(time (compile-files ["pixie/bootstrap.pxi" + "pixie/reader.pxi"] + "/tmp/bootstrap.pxic")) diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index 89d4a948..40d93e65 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -40,7 +40,8 @@ :LET :META :LINE-META - :VAR-CONST]) + :VAR-CONST + :CHAR]) (def *cache* nil) (set-dynamic! (var *cache*)) @@ -255,6 +256,11 @@ (-write-object [this os] (write-tag os NIL)) + Character + (-write-object [this os] + (write-tag os CHAR) + (write-raw-string os (str this))) + Object (-write-object [this os] (throw [:pixie.stdlib/IllegalArgumentException @@ -262,6 +268,7 @@ (defn write-object [os ast] + (binding [*old-meta* (or (and (map? ast) (meta (:form ast))) diff --git a/pixie/vm2/jit_tables.py b/pixie/vm2/jit_tables.py new file mode 100644 index 00000000..1cbb68ed --- /dev/null +++ b/pixie/vm2/jit_tables.py @@ -0,0 +1,67 @@ +from pixie.vm2.object import Type, Object, affirm +from pixie.vm2.code import as_var +import rpython.rlib.jit as jit +from pixie.vm2.primitives import nil, true, false +import pixie.vm2.rt as rt + + +class SwitchTable(Object): + _type = Type(u"pixie.stdlib.SwitchTable") + _immutable_fields_ = ["_switch_table"] + + def type(self): + return SwitchTable._type + + def __init__(self, dict): + self._switch_table = dict + + + @jit.elidable_promote() + def lookup(self, itm): + return self._switch_table(itm, nil) + + def invoke_k(self, args, stack): + affirm(len(args) == 1, u"SwitchTables should be called with one arg") + return self.lookup(args[0]), stack + + + +@as_var("switch-table") +def swith_table__args(args): + affirm(len(args) / 2 == 0, u"Even number of args should be passed to switch-table") + idx = 0 + acc = {} + while idx < len(args): + acc[args[idx]] = args[idx + 1] + idx += 2 + + return SwitchTable(acc) + +class ContainsTable(Object): + _type = Type(u"pixie.stdlib.ContainsTable") + _immutable_fields_ = ["_switch_table"] + + def type(self): + return ContainsTable._type + + def __init__(self, dict): + self._switch_table = dict + + + @jit.elidable_promote() + def lookup(self, itm): + return rt.wrap(itm in self._swith_table) + + def invoke_k(self, args, stack): + affirm(len(args) == 1, u"ContainsTables should be called with one arg") + return self.lookup(args[0]), stack + +@as_var("contains-table") +def contains_table__args(args): + idx = 0 + acc = {} + while idx < len(args): + acc[args[idx]] = args[idx] + idx += 1 + + return ContainsTable(acc) \ No newline at end of file diff --git a/pixie/vm2/pxic_reader.py b/pixie/vm2/pxic_reader.py new file mode 100644 index 00000000..4a5532f8 --- /dev/null +++ b/pixie/vm2/pxic_reader.py @@ -0,0 +1,228 @@ +import pixie.vm2.interpreter as ast +import pixie.vm2.code as code +from pixie.vm2.keyword import keyword +from pixie.vm2.symbol import symbol +from pixie.vm2.primitives import true, false, nil +from pixie.vm2.array import Array +from pixie.vm2.string import char_cache +import pixie.vm2.rt as rt + +class Reader(object): + def __init__(self, filename): + self._file = open(filename, "rb") + self._cache = [] + + def __del__(self): + self._file.close() + + def read(self): + return ord(self._file.read(1)[0]) + + def get_cache_idx(self): + idx = len(self._cache) + self._cache.append(None) + + return idx + + def set_cache(self, idx, obj): + self._cache[idx] = obj + + def get_cache(self, idx): + return self._cache[idx] + + + +bytecodes = ["CACHED_OBJECT", + "INT", + "FLOAT", + "INT_STRING", + "STRING", + "TRUE", + "FALSE", + "NIL", + "VAR", + "KEYWORD", + "SYMBOL", + "NEW_CACHED_OBJECT", + "DO", + "INVOKE", + "VAR", + "CONST", + "FN", + "LOOKUP", + "IF", + "LET", + "META", + "LINE_META", + "VAR_CONST", + "CHAR"] + +for idx, x in enumerate(bytecodes): + globals()[x] = idx + + +def read_utf8_char(os): + ch = os.read() + + if ch <= 0x7F: + n = ch + bytes = 1 + elif (ch & 0xE0) == 0xC0: + n = ch & 31 + bytes = 2 + elif (ch & 0xF0) == 0xE0: + n = ch & 15 + bytes = 3 + elif (ch & 0xF8) == 0xF0: + n = ch & 7 + bytes = 4 + else: + raise AssertionError("Bad unicode character " + str(ch)) + + i = bytes - 1 + while i > 0: + + i -= 1 + n = (n << 6) | (os.read() & 0x3F) + + return unichr(n) + +def read_raw_int(os): + return os.read() | (os.read() << 8) | (os.read() << 16) | (os.read() << 24) + + + +def read_raw_string(os): + buf = [] + for x in range(read_raw_int(os)): + buf.append(read_utf8_char(os)) + + return u"".join(buf) + +def read_raw_list(os): + vals = [None] * read_raw_int(os) + for x in range(len(vals)): + vals[x] = read_object(os) + return vals + +def read_object(os): + tag = os.read() + + if tag == DO: + statements = [None] * read_raw_int(os) + for x in range(len(statements)): + statements[x] = read_object(os) + + meta = read_object(os) + return ast.Do(statements, meta) + + elif tag == INVOKE: + args = [None] * read_raw_int(os) + for x in range(len(args)): + args[x] = read_object(os) + + meta = read_object(os) + return ast.Invoke(args, meta=meta) + + elif tag == NEW_CACHED_OBJECT: + idx = os.get_cache_idx() + o = read_object(os) + os.set_cache(idx, o) + return o + + elif tag == VAR: + ns = read_raw_string(os) + name = read_raw_string(os) + return ast.VDeref(code.intern_var(ns, name)) + + + elif tag == VAR_CONST: + ns = read_raw_string(os) + name = read_raw_string(os) + return ast.Const(code.intern_var(ns, name), nil) + + elif tag == CONST: + return ast.Const(read_object(os)) + + elif tag == CACHED_OBJECT: + return os.get_cache(read_raw_int(os)) + + elif tag == FN: + name_str = read_raw_string(os) + name = keyword(name_str) + args = read_raw_list(os) + closed_overs = read_raw_list(os) + body = read_object(os) + meta = read_object(os) + return ast.Fn(name=name, args=args, body=body, closed_overs=closed_overs, meta=meta) + + elif tag == LOOKUP: + return ast.Lookup(read_object(os), read_object(os)) + + elif tag == KEYWORD: + return keyword(read_raw_string(os)) + + elif tag == SYMBOL: + return symbol(read_raw_string(os)) + + elif tag == FALSE: + return false + + elif tag == TRUE: + return true + + elif tag == NIL: + return nil + + elif tag == INT: + return rt.wrap(read_raw_int(os)) + + elif tag == INT_STRING: + s = read_raw_string(os) + return rt.wrap(int(s)) + + elif tag == IF: + return ast.If(read_object(os), + read_object(os), + read_object(os), + read_object(os)) + + elif tag == LET: + bc = read_raw_int(os) + names = [None] * bc + values = [None] * bc + for idx in range(bc): + names[idx] = read_object(os) + values[idx] = read_object(os) + + body = read_object(os) + meta = read_object(os) + return ast.Let(names=names, bindings=values, body=body, meta=meta) + + elif tag == META: + line = read_object(os) + assert isinstance(line, ast.Meta) + col = read_raw_int(os) + return ast.Meta(line._c_line_tuple, col) + + elif tag == LINE_META: + file = read_raw_string(os) + line = read_raw_string(os) + line_number = read_raw_int(os) + return ast.Meta((line, file, line_number), 0) + + elif tag == STRING: + str = read_raw_string(os) + return rt.wrap(str) + + elif tag == CHAR: + str = read_raw_string(os) + return char_cache.intern(ord(str[0])) + + raise AssertionError("No valid handler for TAG " + bytecodes[tag]) + + +def read_file(filename): + return read_object(Reader(filename)) + + diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index 4f513b08..b2aa2694 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -71,6 +71,7 @@ def wrapper(*args): #import pixie.vm.threads #import pixie.vm.string_builder #import pixie.vm.stacklet + import pixie.vm2.jit_tables @specialize.argtype(0) def wrap(x): diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index 85858f65..e8bbe799 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -6,6 +6,7 @@ #import pixie.vm2.stdlib as proto #import pixie.vm2.util as util from rpython.rlib.rarithmetic import intmask, r_uint +import rpython.rlib.jit as jit #from pixie.vm2.libs.pxic.util import add_marshall_handlers class String(Object): @@ -72,20 +73,46 @@ def __init__(self, s): # return false # return true if self._str == v._str else false # -# class Character(Object): -# _type = Type(u"pixie.stdlib.Character") -# _immutable_fields_ = ["_char_val"] -# -# def type(self): -# return Character._type -# -# def __init__(self, i): -# assert isinstance(i, int) -# self._char_val = i -# -# def char_val(self): -# return self._char_val -# +class Character(Object): + _type = Type(u"pixie.stdlib.Character") + _immutable_fields_ = ["_char_val"] + + def type(self): + return Character._type + + def __init__(self, i): + assert isinstance(i, int) + self._char_val = i + + def char_val(self): + return self._char_val + +class CharCache(object): + def __init__(self): + self._char_cache = {} + self._rev = 0 + + @jit.elidable_promote() + def intern_inner(self, ival, rev): + return self._char_cache.get(ival, None) + + def intern(self, ival): + v = self.intern_inner(ival, self._rev) + if not v: + v = Character(ival) + self._char_cache[ival] = v + self._rev += 1 + + return v + +char_cache = CharCache() + +@as_var("char") +def char(val): + affirm(isinstance(val, Integer), u"First argument must be an Integer") + return char_cache.intern(val.int_val()) + + # @wrap_fn # def write_char(obj): # assert isinstance(obj, Character) diff --git a/target2.py b/target2.py index efa3d7ef..a6b3bac9 100644 --- a/target2.py +++ b/target2.py @@ -8,13 +8,17 @@ from pixie.vm2.keyword import keyword as kw from pixie.vm2.symbol import symbol as sym from pixie.vm2.numbers import parse_number -from pixie.vm2.pxic_reader import read_file +from pixie.vm2.pxic_reader import read_file, read_object, Reader rt.init() def testit(max): + rdr = Reader("/tmp/bootstrap.pxic") + while True: + obj = read_object(rdr) + run_stack(None, i.InterpretK(obj, None)) - pixie_code = read_file("/tmp/bootstrap.pxic") + #pixie_code = read_file("/tmp/bootstrap.pxic") return run_stack(None, i.InterpretK(pixie_code, None)) From 67ff2ea2b4878f6db28848032e2072103ffc0796 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Fri, 12 Jun 2015 07:00:42 -0600 Subject: [PATCH 21/46] latest work --- pixie/bootstrap.pxi | 64 ++++++++++++++++++++++++++++++++++++++++ pixie/stdlib.pxi | 20 ++++++++++++- pixie/vm2/jit_tables.py | 10 +++---- pixie/vm2/pxic_reader.py | 5 +++- pixie/vm2/string.py | 30 +++++++++++++++++++ target2.py | 10 ++++--- 6 files changed, 128 insertions(+), 11 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index a09c8bc6..0a9d380a 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -336,6 +336,8 @@ (next coll)) (seq res)))) +;; Cons and List + (deftype Cons [first next meta] ISeq (-first [this] first) @@ -350,6 +352,45 @@ (defn cons [head tail] (->Cons head (seq tail) nil)) + +(deftype List [head tail cnt hash-val meta] + ISeq + (-first [this] first) + (-next [this] next) + + ICounted + (-count [this] cnt) + + ISeqable + (-seq [this] this) + + IMeta + (-meta [this] meta) + (-with-meta [this new-meta] + (->List head tail cnt hash-val meta)) + + IPersistentCollection + (-conj [this val] + (->List val this (inc cnt) nil nil))) + + +(defn list [& args] + (loop [acc nil + idx (dec (count args)) + cnt 0] + (if (pos? idx) + (recur (->List (nth args idx) + acc + cnt + nil + nil) + (dec idx) + (inc cnt)) + acc))) + +(defn vector [& args] + (vector-from-array args)) + ;; String Builder (defn string-builder @@ -728,6 +769,29 @@ (in-ns :pixie.stdlib) +;; Extend String + +(extend-type String + IIndexed + (-nth [self idx] + (-str-nth self idx)) + + ICounted + (-count [self] + (-str-len self)) + + IReduce + (-reduce [self f init] + (loop [acc init + idx 0] + (if (< idx (count self)) + (if (reduced? acc) + @acc + (recur (f acc (nth self idx)) + (inc idx))) + acc)))) + +;; End Extend String ;; Extend Array diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index cdf5a95f..04c39b18 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -2316,7 +2316,7 @@ Calling this function on something that is not ISeqable returns a seq with that (defn mapv ([f col] - (transduce (map f) conj col))) + (transduce (map f) conj! col))) (defn macroexpand-1 {:doc "If form is a macro call, returns the expanded form. Does nothing if not a macro call." @@ -2449,3 +2449,21 @@ Calling this function on something that is not ISeqable returns a seq with that `(def ~x (~'pixie.stdlib/-effect-fn (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))) sigs))) + + +(extend -transient PersistentHashMap + (fn [m] + (reduce + (fn [acc [k v]] + (add-to-dict-map acc k v)) + (new-dict-map) + m))) + +(extend -persistent! PersistentHashMap identity) + +(extend -persistent! DictMap dict-map-to-phm) +(extend -assoc DictMap add-to-dict-map) +(extend -conj DictMap (fn [m [k v]] + (assoc m k v))) +(extend -val-at DictMap (fn [m k _] + (get-from-dict-map m k))) diff --git a/pixie/vm2/jit_tables.py b/pixie/vm2/jit_tables.py index 1cbb68ed..bce16cef 100644 --- a/pixie/vm2/jit_tables.py +++ b/pixie/vm2/jit_tables.py @@ -12,13 +12,13 @@ class SwitchTable(Object): def type(self): return SwitchTable._type - def __init__(self, dict): - self._switch_table = dict + def __init__(self, d): + self._switch_table = d @jit.elidable_promote() def lookup(self, itm): - return self._switch_table(itm, nil) + return self._switch_table.get(itm, nil) def invoke_k(self, args, stack): affirm(len(args) == 1, u"SwitchTables should be called with one arg") @@ -28,10 +28,10 @@ def invoke_k(self, args, stack): @as_var("switch-table") def swith_table__args(args): - affirm(len(args) / 2 == 0, u"Even number of args should be passed to switch-table") idx = 0 acc = {} while idx < len(args): + affirm(idx + 1 < len(args), u"Even number of args should be passed to switch-table") acc[args[idx]] = args[idx + 1] idx += 2 @@ -50,7 +50,7 @@ def __init__(self, dict): @jit.elidable_promote() def lookup(self, itm): - return rt.wrap(itm in self._swith_table) + return rt.wrap(itm in self._switch_table) def invoke_k(self, args, stack): affirm(len(args) == 1, u"ContainsTables should be called with one arg") diff --git a/pixie/vm2/pxic_reader.py b/pixie/vm2/pxic_reader.py index 4a5532f8..1226bb48 100644 --- a/pixie/vm2/pxic_reader.py +++ b/pixie/vm2/pxic_reader.py @@ -16,7 +16,10 @@ def __del__(self): self._file.close() def read(self): - return ord(self._file.read(1)[0]) + try: + return ord(self._file.read(1)[0]) + except IndexError: + raise EOFError def get_cache_idx(self): idx = len(self._cache) diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index e8bbe799..b12a2863 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -18,6 +18,22 @@ def type(self): def __init__(self, s): #assert isinstance(s, unicode) self._str = s + + +@as_var("-str-len") +def str_len(self): + assert isinstance(self, String) + return rt.wrap(len(self._str)) + +@as_var("-str-nth") +def str_len(self, idx): + assert isinstance(self, String) + i = idx.int_val() + return char_cache.intern(ord(self._str[i])) + + + + # # # @extend(proto._str, String) @@ -87,6 +103,19 @@ def __init__(self, i): def char_val(self): return self._char_val + + def to_str(self): + assert isinstance(self, Character) + return rt.wrap(u"" + unichr(self.char_val())) + + def to_repr(self): + assert isinstance(self, Character) + cv = self.char_val() + if cv < 128: + return rt.wrap(u"\\"+unicode(chr(cv))) + hexv = rt.name(rt.bit_str(rt.wrap(self.char_val()), rt.wrap(4))) + return rt.wrap(u"\\u" + u"0" * (4 - len(hexv)) + hexv) + class CharCache(object): def __init__(self): self._char_cache = {} @@ -105,6 +134,7 @@ def intern(self, ival): return v + char_cache = CharCache() @as_var("char") diff --git a/target2.py b/target2.py index a6b3bac9..e3eb2445 100644 --- a/target2.py +++ b/target2.py @@ -15,13 +15,15 @@ def testit(max): rdr = Reader("/tmp/bootstrap.pxic") while True: - obj = read_object(rdr) + try: + obj = read_object(rdr) + except EOFError: + break run_stack(None, i.InterpretK(obj, None)) + return None #pixie_code = read_file("/tmp/bootstrap.pxic") - - - return run_stack(None, i.InterpretK(pixie_code, None)) + #return run_stack(None, i.InterpretK(pixie_code, None)) #val = testit() #print val.int_val(), val From c85ac1a5331a589f81f7bf16bb6957675e022ef9 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sat, 13 Jun 2015 16:27:11 -0600 Subject: [PATCH 22/46] the new interpreter can parse a vector of ints via a reader compile via pixie --- pixie/bootstrap.pxi | 36 +++++++++++++++++++++++++++++------- pixie/compiler.pxi | 8 +++++--- pixie/vm2/string.py | 9 +++++---- target2.py | 2 +- 4 files changed, 40 insertions(+), 15 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 0a9d380a..5ecc268c 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -286,6 +286,10 @@ ([coll idx not-found] (-nth-not-found coll idx not-found))) +(defn has-meta? + [x] + (satisfies? IMeta x)) + (defn count ([coll] (-count coll))) @@ -388,25 +392,26 @@ (inc cnt)) acc))) -(defn vector [& args] - (vector-from-array args)) ;; String Builder (defn string-builder ([] (-string-builder)) - ([sb] (-str sb)) + ([sb] (-internal-to-str sb)) ([sb x] (if (instance? String x) (-add-to-string-builder x) - (-add-to-string-bulder (-str x))))) + (-str x (fn [x] + (-add-to-string-builder sb x)))))) -(defn str [& args] - (transduce - (map str) +(defn str + [& args] + (reduce string-builder args)) + + (defn println [& args] (let [sb (-string-builder) add-fn (fn [x] @@ -962,6 +967,19 @@ this)] (set-field! this :hash-val val) val))) + + (-str [this sb] + (sb "[") + (let [not-first (atom false)] + (reduce + (fn [_ x] + (if @not-first + (sb " ") + (reset! not-first true)) + (-str x sb)) + nil + this)) + (sb "]")) IMessageObject @@ -1601,6 +1619,10 @@ (extend -eq Float -num-eq) (extend -eq Ratio -num-eq) +(defn vector [& args] + (pixie.stdlib.persistent-vector/vector-from-array args)) + + ;; End Extend Core Types diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 8def7f47..4ccc8bc0 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -236,7 +236,7 @@ (defmethod analyze-seq 'recur [[_ & args]] - () + (assert (:tail? *env*) "Can only recur at tail position") (analyze-form `(~'__loop__fn__ ~@args))) (defmethod analyze-seq 'def @@ -433,7 +433,9 @@ 'size-t true 'bit-count32 true 'contains-table true - 'switch-table true}}) + 'switch-table true + '-add-to-string-builder true + '-parse-number true}}) :tail? true}) @@ -665,4 +667,4 @@ (time (compile-files ["pixie/bootstrap.pxi" "pixie/reader.pxi"] - "/tmp/bootstrap.pxic")) + "./bootstrap.pxic")) diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index b12a2863..2b4bcf02 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -106,15 +106,16 @@ def char_val(self): def to_str(self): assert isinstance(self, Character) - return rt.wrap(u"" + unichr(self.char_val())) + return u"" + unichr(self.char_val()) def to_repr(self): assert isinstance(self, Character) cv = self.char_val() if cv < 128: - return rt.wrap(u"\\"+unicode(chr(cv))) - hexv = rt.name(rt.bit_str(rt.wrap(self.char_val()), rt.wrap(4))) - return rt.wrap(u"\\u" + u"0" * (4 - len(hexv)) + hexv) + return u"\\"+unicode(chr(cv)) + return u"FIXME" + #hexv = rt.name(rt.bit_str(rt.wrap(self.char_val()), rt.wrap(4))) + #return rt.wrap(u"\\u" + u"0" * (4 - len(hexv)) + hexv) class CharCache(object): def __init__(self): diff --git a/target2.py b/target2.py index e3eb2445..ae946ab1 100644 --- a/target2.py +++ b/target2.py @@ -13,7 +13,7 @@ rt.init() def testit(max): - rdr = Reader("/tmp/bootstrap.pxic") + rdr = Reader("./bootstrap.pxic") while True: try: obj = read_object(rdr) From 6a6688613893e46b8ca45de70a74c9747cc5019d Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 15 Jun 2015 22:53:38 -0600 Subject: [PATCH 23/46] reworked the compiler a bit --- pixie/compiler.pxi | 413 ++++++++++++------------------------------ pixie/io.pxi | 28 +-- pixie/pxic-writer.pxi | 241 +++++++++++++----------- pixie/stdlib.pxi | 104 ++++++----- 4 files changed, 321 insertions(+), 465 deletions(-) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 4ccc8bc0..7104d849 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -2,7 +2,9 @@ (:require [pixie.io :as io] [pixie.string :as string] [pixie.time :refer [time]] - [pixie.pxic-writer :as pxic-writer])) + [pixie.pxic-writer :as pxic-writer] + [pixie.ast :refer :all])) + (def macro-overrides { @@ -105,30 +107,23 @@ [x] (let [statement-asts (binding [*env* (assoc *env* :tail? false)] (mapv analyze-form (butlast (next x))))] - {:op :do - :children '[:statements :ret] - :env *env* - :form x - :statements statement-asts - :ret (analyze-form (last x))})) + (->Do statement-asts + (analyze-form (last x)) + x + *env*))) (defmethod analyze-seq 'comment [x] - {:op :const - :type (keyword "nil") - :form x - :env *env*}) + (->Const x *env*)) (defmethod analyze-seq 'if [[_ test then else :as form]] - {:op :if - :children '[:test :then :else] - :env *env* - :form form - :test (binding [*env* (assoc *env* :tail? false)] + (->If (binding [*env* (assoc *env* :tail? false)] (analyze-form test)) - :then (analyze-form then) - :else (analyze-form else)}) + (analyze-form then) + (analyze-form else) + form + *env*)) (defmethod analyze-seq 'fn* @@ -145,60 +140,35 @@ (partial analyze-fn-body name) {} arities)] - {:op :fn - :env *env* - :form form - :name name - :children '[:arities] - :arities (vals analyzed-bodies)} - )) - -(defn analyze-fn-body [fn-name acc [args & body]] - ; TODO: Add support for variadic fns + (->Fn name + (vals analyzed-bodies) + form + *env*))) + +(defn add-local [env type bind-name] + (assoc-in env [:locals bind-name] (->Binding type bind-name bind-name *env*))) + +(defn analyze-fn-body [fn-name acc [args & body :as form]] (let [[args variadic?] (let [not& (vec (filter (complement (partial = '&)) args))] [not& (= '& (last (butlast args)))]) arity (count args) arity-idx (if variadic? -1 arity) - new-env (update-in *env* [:locals] (fn [locals] - (reduce - (fn [locals [k v]] - (assoc locals k (assoc v :closed-overs #{k}))) - {} - locals))) - new-env (assoc-in new-env [:locals fn-name] {:op :binding - :type :fn-self - :name fn-name - :form fn-name - :env *env*}) + new-env (add-local *env* :fn-self fn-name) new-env (reduce - (fn [acc idx] - (let [arg-name (nth args idx)] - (assoc-in acc [:locals arg-name] {:op :binding - :type :arg - :idx idx - :name arg-name - :form arg-name - :env *env*}))) + (fn [acc arg-name] + (add-local acc :arg arg-name)) new-env - (range (count args)))] + args)] (assert (not (acc arity-idx)) (str "Duplicate arity for " (cons args body))) - (assoc acc arity-idx {:op :fn-body - :env *env* - :arity arity - :args args - :variadic? variadic? - :children '[:body] - :body (binding [*env* (assoc new-env :tail? true)] - (analyze-form (cons 'do body)))}))) - -(defn analyze-let-body - [acc [name binding & rest :as form]] - {:op :let - :form form - :children '[:binding :body] - :env *env* - :name name - :body acc}) + (assoc acc arity-idx (->FnBody fn-name + arity + args + nil + variadic? + (binding [*env* (assoc new-env :tail? true)] + (analyze-form (cons 'do body))) + form + *env*)))) (defmethod analyze-seq 'let* [[_ bindings & body :as form]] @@ -207,25 +177,20 @@ [new-env bindings] (reduce (fn [[new-env bindings] [name binding-form]] (let [binding-ast (binding [*env* new-env] - {:op :binding - :type :let - :children '[:value] - :form binding-form - :env *env* - :name name - :value (binding [*env* (assoc *env* :tail? false)] - (analyze-form binding-form))})] + (->LetBinding name + (binding [*env* (assoc *env* :tail? false)] + (analyze-form binding-form)) + binding-form + *env*))] [(assoc-in new-env [:locals name] binding-ast) (conj bindings binding-ast)])) [*env* []] parted)] - {:op :let - :form form - :children '[:bindings :body] - :bindings bindings - :env *env* - :body (binding [*env* new-env] - (analyze-form `(do ~@body)))})) + (->Let bindings + (binding [*env* new-env] + (analyze-form `(do ~@body))) + form + *env*))) (defmethod analyze-seq 'loop* [[_ bindings & body]] @@ -243,12 +208,11 @@ [[_ nm val :as form]] (swap! (:vars *env*) update-in [(:ns *env*) nm] (fn [x] (or x :def))) - {:op :def - :name nm - :form form - :env *env* - :children '[:val] - :val (analyze-form val)}) + (->Def + nm + (analyze-form val) + form + *env*)) (defmethod analyze-seq 'quote [[_ val]] @@ -276,17 +240,11 @@ (defmethod analyze-form nil [_] - {:op :const - :type (keyword "nil") - :env *env* - :form nil}) + (->Const nil *env*)) (defmethod analyze-form :bool [form] - {:op :const - :type :bool - :env *env* - :form form}) + (->Const form *env*)) (defn keep-meta [new old] (if-let [md (meta old)] @@ -300,13 +258,13 @@ (let [resolved (try (and (symbol? sym) (resolve-in (the-ns (:ns *env*)) sym)) (catch :pixie.stdlib/AssertionException ex - nil))] + nil))] (cond (and (symbol? sym) (string/starts-with? (name sym) ".-")) (let [sym-kw (keyword (string/substring (name sym) 2)) result (analyze-form (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw) - form))] + form))] result) (contains? macro-overrides resolved) @@ -319,44 +277,30 @@ form)) :else - {:op :invoke - :tail-call (:tail? *env*) - :children '[:fn :args] - :form form - :env *env* - :fn (binding [*env* (assoc *env* :tail? false)] - (analyze-form sym)) - :args (binding [*env* (assoc *env* :tail? false)] - (mapv analyze-form args))}))) + (->Invoke (binding [*env* (assoc *env* :tail? false)] + (analyze-form sym)) + (binding [*env* (assoc *env* :tail? false)] + (mapv analyze-form args)) + (:tail? *env*) + form + *env*)))) (defmethod analyze-form :number [x] - {:op :const - :type :number - :form x - :env *env*}) + (->Const x *env*)) (defmethod analyze-form :keyword [x] - {:op :const - :type :keyword - :form x - :env *env*}) + (->Const x *env*)) (defmethod analyze-form :string [x] - {:op :const - :type :string - :form x - :env *env*}) + (->Const x *env*)) (defmethod analyze-form :char [x] - {:op :const - :type :char - :form x - :env *env*}) + (->Const x *env*)) (defmethod analyze-form :seq [x] @@ -372,11 +316,9 @@ (defmethod analyze-form :vector [x] - {:op :vector - :children [:items] - :items (mapv analyze-form x) - :form x - :env *env*}) + (->Vector (mapv analyze-form x) + x + *env*)) (defn maybe-var [x] (let [namesp (the-ns (:ns *env*)) @@ -386,40 +328,35 @@ nil)) result (cond (namespace x) - {:op :var - :env *env* - :ns (symbol (namespace x)) - :name (symbol (name x)) - :form x} + (->Var (symbol (namespace x)) + (symbol (name x)) + x + *env*) (get-in @(:vars *env*) [(:ns *env*) x]) - {:op :var - :env *env* - :ns (:ns *env*) - :name x - :form x} + (->Var (:ns *env*) + x + x + *env*) ;; Hack until we get proper refers (get-in @(:vars *env*) ['pixie.stdlib x]) - {:op :var - :env *env* - :ns 'pixie.stdlib - :name x - :form x} - + (->Var 'pixie.stdlib + x + x + *env*) + resolved - {:op :var - :env *env* - :ns (namespace resolved) - :name (name resolved) - :form x} - + (->Var (namespace resolved) + (name resolved) + x + *env*) + :else - {:op :var - :env *env* - :ns (name (:ns *env*)) - :name (name x) - :form x})] + (->Var (name (:ns *env*)) + (name x) + x + *env*))] result)) @@ -428,15 +365,17 @@ (defn new-env "Creates a new (empty) environment" [] - {:ns 'pixie.stdlib - :vars (atom {'pixie.stdlib {'array true - 'size-t true - 'bit-count32 true - 'contains-table true - 'switch-table true - '-add-to-string-builder true - '-parse-number true}}) - :tail? true}) + (->Env + 'pixie.stdlib + (atom {'pixie.stdlib {'array true + 'size-t true + 'bit-count32 true + 'contains-table true + 'switch-table true + '-add-to-string-builder true + '-parse-number true}}) + {} + true)) (defn analyze @@ -451,7 +390,6 @@ - (defn walk [pre post selector node] (let [walk-fn (partial walk pre post selector)] (-> (reduce @@ -467,16 +405,8 @@ post))) (defn post-walk [f ast] - (walk identity f :children ast)) + (walk identity f children-keys ast)) -(defn clean-do [ast] - (post-walk - (fn [{:keys [op statements ret] :as ast}] - (if (and (= op :do) - (= (count statements) 0)) - ret - ast)) - ast)) (defn child-seq [ast] (mapcat @@ -486,18 +416,21 @@ (seq? child)) child [child]))) - (:children ast))) - -(def collect-closed-overs - (fn [{:keys [op args env closed-overs] :as ast}] - (let [{:keys [locals]} env - closed-overs (set (or closed-overs - (mapcat :closed-overs (child-seq ast)))) - closed-overs (if (= op :fn-body) - (reduce disj closed-overs args) - closed-overs)] - (assoc ast :closed-overs closed-overs))) - ast) + (children-keys ast))) + +;; Collect Closed Overs + + +(defn collect-closed-overs [ast] + (let [closed-overs (set (or (get-closed-overs ast) + (mapcat get-closed-overs (child-seq ast)))) + closed-overs (if (instance? FnBody ast) + (reduce disj closed-overs (:args ast)) + closed-overs)] + (assoc-closed-overs ast closed-overs))) + + +;; End Collect Closed Overs (defn remove-env [ast] (walk #(dissoc % :env) @@ -505,121 +438,15 @@ :children ast)) -(defn make-invoke-ast [fn args form env] - {:op :invoke - :children '[:fn :args] - :form form - :env env - :fn fn - :args args}) - -(defn make-var-ast [ns name env] - {:op :var - :ns ns - :name name - :env env - :form (symbol (pixie.stdlib/name name))}) - -(defn make-var-const-ast [ns name env] - {:op :var-const - :ns ns - :name name - :env env - :form (symbol (pixie.stdlib/name name))}) - -(defn make-invoke-var-ast [ns name args form env] - (make-invoke-ast - (make-var-ast ns name env) - args - form - env)) - -(def convert-defs - (fn [{:keys [op name env val form] :as ast}] - (if (= op :def) - (make-invoke-var-ast - "pixie.stdlib" - "set-var-root!" - [(make-var-const-ast (:ns env) name env) - val] - form - env) - ast)) - identity - :children - ast) - -(defn pass-for [op-for f] - (fn [{:keys [op] :as ast}] - (if (= op op-for) - (f ast) - ast))) - -(def convert-fns - (pass-for :fn - (fn [{:keys [name arities form env]}] - (if (= (count arities) 1) - (convert-fn-body name (first arities)) - (make-invoke-var-ast - "pixie.stdlib" - "multi-arity-fn" - (vec (concat [{:op :const - :form (pixie.stdlib/name name) - :env env}] - (mapcat - (fn [{:keys [args variadic?] :as body}] - [{:op :const - :form (if variadic? - -1 - (count args)) - :env env} - (convert-fn-body name body)]) - arities))) - form - env))))) - - -(defn convert-fn-body [name {:keys [variadic? args body form env] :as ast}] - (if variadic? - (make-invoke-var-ast - "pixie.stdlib" - "variadic-fn" - [{:op :const - :form (dec (count args)) - :env env} - (convert-fn-body name (dissoc ast :variadic?))] - form - env) - (assoc ast - :op :fn-body - :name name))) - -(def convert-vectors - (pass-for :vector - (fn [{:keys [items form env]}] - (make-invoke-var-ast - "pixie.stdlib" - "array" - items - form - env)))) (defn run-passes [ast] (walk identity - (comp - persistent! - (comp convert-vectors - convert-fns - (comp convert-defs - collect-closed-overs - (comp clean-do - #_transient)))) - :children + identity #_simplify-ast + children-keys ast)) (defn read-and-compile [form env] - (let [ast (analyze form env) - ast (run-passes ast)] + (let [ast (analyze form env)] ast)) #_(defn compile-file [from to] diff --git a/pixie/io.pxi b/pixie/io.pxi index c80f2e1a..440eab36 100644 --- a/pixie/io.pxi +++ b/pixie/io.pxi @@ -156,9 +156,8 @@ kl nil when all lines have been read" (defn spit "Writes the content to output. Output must be a file or an IOutputStream." -<<<<<<< HEAD ([output content] - (spit output content true)) + (spit output content false)) ([output content dispose?] (cond (string? output) @@ -182,28 +181,9 @@ kl nil when all lines have been read" (utf8/utf8-output-stream-rf dispose?)) (str content)) - :else (throw [:pixie.stdlib/InvalidInputException - "Expected a string or IOutputStream"])))) -======= - [output content] - (cond - (string? output) - (transduce (map identity) - (-> output - open-write - buffered-output-stream - utf8/utf8-output-stream-rf) - (str content)) - - (satisfies? IOutputStream output) - (transduce (map identity) - (-> output - buffered-output-stream - utf8/utf8-output-stream-rf) - (str content)) - - :else (throw [::Exception "Expected a string or IOutputStream"]))) ->>>>>>> master + + + :else (throw [::Exception "Expected a string or IOutputStream"])))) (defn slurp "Reads in the contents of input. Input must be a filename or an IInputStream" diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index 40d93e65..495d4cc9 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -1,5 +1,6 @@ (ns pixie.pxic-writer - (:require [pixie.streams :refer [write-byte]] + (:require [pixie.ast :as ast] + [pixie.streams :refer [write-byte]] [pixie.streams.utf8 :refer [utf8-output-stream-rf]] [pixie.io :refer [spit]])) @@ -98,12 +99,12 @@ (let [m (or (meta (:form ast)) *old-meta*)] (if m - (write-object os {:op :meta - :line {:op :line-meta - :line (str (:line m)) - :file (:file m) - :line-number (:line-number m)} - :column-number (:column-number m)}) + (write-object os (ast/->Meta + (ast/->LineMeta + (str (:line m)) + (:file m) + (:line-number m)) + (:column-number m))) (write-object os nil)))) (defn write-tag [os tag] @@ -115,105 +116,130 @@ (defmulti write-ast (fn [os ast] (:op ast))) -(defmethod write-ast :do - [os {:keys [statements ret] :as ast}] - (write-tag os DO) - (write-int-raw os (inc (count statements))) - (doseq [statement statements] - (write-object os statement)) - (write-object os ret) - (write-meta os ast)) - -(defmethod write-ast :invoke - [os {:keys [fn args] :as ast}] - (write-tag os INVOKE) - (write-int-raw os (inc (count args))) - (write-object os fn) - (doseq [arg args] - (write-object os arg)) - (write-meta os ast)) - -(defmethod write-ast :var - [os {:keys [ns name]}] - (write-cached-obj *cache* - [:deref ns name] - (fn [_ ns name] - (write-tag os VAR) - (write-raw-string os (str ns)) - (write-raw-string os (str name))))) - -(defmethod write-ast :var-const - [os {:keys [ns name]}] - (write-cached-obj *cache* - [:const ns name] - (fn [_ ns name] - (write-tag os VAR-CONST) - (write-raw-string os (str ns)) - (write-raw-string os (str name))))) - -(defmethod write-ast :const - [os {:keys [form]}] - (write-tag os CONST) - (write-object os form)) - -(defmethod write-ast :fn-body - [os {:keys [name args closed-overs body] :as ast}] - (write-tag os FN) - (write-raw-string os (str name)) - (write-int-raw os (count args)) - (doseq [arg args] - (write-object os (keyword (str arg)))) - (write-int-raw os (count closed-overs)) - (doseq [co closed-overs] - (write-object os (keyword (str co)))) - (write-object os body) - (write-meta os ast)) - -(defmethod write-ast :binding - [os {:keys [name] :as ast}] - (write-tag os LOOKUP) - (write-object os (keyword (pixie.stdlib/name name))) - (write-meta os ast)) - -(defmethod write-ast :if - [os {:keys [test then else] :as ast}] - (write-tag os IF) - (write-object os test) - (write-object os then) - (write-object os else) - (write-meta os ast)) - -(defmethod write-ast :let - [os {:keys [bindings body] :as ast}] - (write-tag os LET) - (write-int-raw os (count bindings)) - (doseq [{:keys [name value]} bindings] - (write-object os (keyword (pixie.stdlib/name name))) - (write-object os value)) - (write-object os body) - (write-meta os ast)) - -(defmethod write-ast :meta - [os {:keys [line column-number]}] - (write-tag os META) - (write-object os line) - (write-int-raw os column-number)) - -(defmethod write-ast :line-meta - [os ast] - (write-cached-obj *cache* - [:line-meta ast] - (fn [_ {:keys [line file line-number]}] - (write-tag os LINE-META) - (write-raw-string os file) - (write-raw-string os line) - (write-int-raw os line-number)))) -(extend-protocol IPxicObject - IMap - (-write-object [this os] - (write-ast os this)) + + + + + + + + +(extend-protocol IPxicObject + + ast/If + (-write-object [{:keys [test then else] :as ast} os] + (write-tag os IF) + (write-object os test) + (write-object os then) + (write-object os else) + (write-meta os ast)) + + ast/Let + (-write-object [{:keys [bindings body] :as ast} os] + (write-tag os LET) + (write-int-raw os (count bindings)) + (doseq [{:keys [name value]} bindings] + (write-object os (keyword (pixie.stdlib/name name))) + (write-object os value)) + (write-object os body) + (write-meta os ast)) + + + ast/LetBinding + (-write-object + [{:keys [name] :as ast} os] + (write-tag os LOOKUP) + (write-object os (keyword (pixie.stdlib/name name))) + (write-meta os ast)) + + + ast/Binding + (-write-object + [{:keys [name] :as ast} os] + (write-tag os LOOKUP) + (write-object os (keyword (pixie.stdlib/name name))) + (write-meta os ast)) + + + ast/FnBody + (-write-object [{:keys [name args closed-overs body] :as ast} os] + (write-tag os FN) + (write-raw-string os (str name)) + (write-int-raw os (count args)) + (doseq [arg args] + (write-object os (keyword (str arg)))) + (write-int-raw os (count closed-overs)) + (doseq [co closed-overs] + (write-object os (keyword (str co)))) + (write-object os body) + (write-meta os ast)) + + + + ast/Meta + (-write-object [{:keys [line column-number]} os] + (write-tag os META) + (write-object os line) + (write-int-raw os column-number)) + + ast/LineMeta + (-write-object [ast os] + (write-cached-obj *cache* + [:line-meta ast] + (fn [_ {:keys [line file line-number]}] + (write-tag os LINE-META) + (write-raw-string os file) + (write-raw-string os line) + (write-int-raw os line-number)))) + + + + ast/Const + (-write-object [{:keys [form]} os] + (write-tag os CONST) + (write-object os form)) + + + ast/VarConst + (-write-object [{:keys [ns name]} os] + (write-cached-obj *cache* + [:const ns name] + (fn [_ ns name] + (write-tag os VAR-CONST) + (write-raw-string os (str ns)) + (write-raw-string os (str name))))) + + ast/Var + (-write-object [{:keys [ns name]} os] + (write-cached-obj *cache* + [:deref ns name] + (fn [_ ns name] + (write-tag os VAR) + (write-raw-string os (str ns)) + (write-raw-string os (str name))))) + + ast/Invoke + (-write-object [{:keys [fn args] :as ast} os] + (write-tag os INVOKE) + (write-int-raw os (inc (count args))) + (write-object os fn) + (doseq [arg args] + (write-object os arg)) + (write-meta os ast)) + + ast/Do + (-write-object [{:keys [statements ret] :as ast} os] + (write-tag os DO) + (write-int-raw os (inc (count statements))) + (doseq [statement statements] + (write-object os statement)) + (write-object os ret) + (write-meta os ast)) + + + String (-write-object [this os] (write-cached-obj *cache* @@ -266,6 +292,11 @@ (throw [:pixie.stdlib/IllegalArgumentException (str "Can't write " this)]))) +(defn simplify [ast] + (let [simplified (ast/simplify-ast ast)] + (if (identical? simplified ast) + ast + (recur simplified)))) (defn write-object [os ast] @@ -273,4 +304,4 @@ (map? ast) (meta (:form ast))) *old-meta*)] - (-write-object ast os))) + (-write-object (simplify ast) os))) diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index f0a35b39..7cf1d242 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -772,6 +772,7 @@ there's a value associated with the key. Use `some` for checking for values." :examples [["((comp inc first) [41 2 3])" nil 42]] :signatures [[f] [f & fs]] :added "0.1"} + ([] identity) ([f] f) ([f1 f2] (fn [& args] @@ -1252,47 +1253,6 @@ Creates new maps if the keys are not present." `(do ~type-decl ~ctor ~@proto-bodies))) - -(defmacro defrecord - {:doc "Define a record type. - -Similar to `deftype`, but supports construction from a map using `map->Type` -and implements IAssociative, ILookup and IObject." - :added "0.1"} - [nm fields & body] - (let [ctor-name (symbol (str "->" (name nm))) - map-ctor-name (symbol (str "map" (name ctor-name))) - fields (transduce (map (comp keyword name)) conj fields) - type-from-map `(defn ~map-ctor-name [m] - (apply ~ctor-name (map #(get m %) ~fields))) - default-bodies ['IAssociative - `(-assoc [self k v] - (let [m (reduce #(assoc %1 %2 (. self %2)) {} ~fields)] - (~map-ctor-name (assoc m k v)))) - `(-contains-key [self k] - (contains? ~(set fields) k)) - `(-dissoc [self k] - (throw [:pixie.stdlib/NotImplementedException - "dissoc is not supported on defrecords"])) - 'ILookup - `(-val-at [self k not-found] - (if (contains? ~(set fields) k) - (. self k) - not-found)) - 'IObject - `(-str [self] - (str "<" ~(name nm) " " (reduce #(assoc %1 %2 (. self %2)) {} ~fields) ">")) - `(-eq [self other] - (and (instance? ~nm other) - ~@(map (fn [field] - `(= (. self ~field) (. other ~field))) - fields))) - `(-hash [self] - (throw [:pixie.stdlib/NotImplementedException "not implemented"]))] - deftype-decl `(deftype ~nm ~fields ~@default-bodies ~@body)] - `(do ~type-from-map - ~deftype-decl))) - (defn print {:doc "Prints the arguments, seperated by spaces." :added "0.1"} @@ -2458,8 +2418,6 @@ Calling this function on something that is not ISeqable returns a seq with that (let ~(vec (interleave bindings binding-syms)) ~@body))))) -<<<<<<< HEAD - (defmacro with-handler [[h handler] & body] `(let [~h ~handler] (~'pixie.stdlib/-effect-return @@ -2494,6 +2452,8 @@ Calling this function on something that is not ISeqable returns a seq with that (extend -assoc DictMap add-to-dict-map) (extend -conj DictMap (fn [m [k v]] (assoc m k v))) +(extend -conj! DictMap (fn [m [k v]] + (assoc m k v))) (extend -val-at DictMap (fn [m k _] (get-from-dict-map m k))) @@ -2501,3 +2461,61 @@ Calling this function on something that is not ISeqable returns a seq with that (fn [v] (str ""))) (extend -repr Namespace -str) + + +(defn -make-record-assoc-body [cname fields] + (let [k-sym (gensym "k") + v-sym (gensym "v") + this-sym (gensym "this") + result `(-assoc [~this-sym ~k-sym ~v-sym] + (case ~k-sym + ~@(mapcat + (fn [k] + [k `(~cname ~@(mapv (fn [x] + (if (= x k) + v-sym + `(get-field ~this-sym ~x))) + fields))]) + fields) + (throw [:pixie.stdlib/NotImplementedException + (str "Can't assoc to a unknown field: " ~k-sym)])))] + result)) + +(defmacro defrecord + {:doc "Define a record type. + +Similar to `deftype`, but supports construction from a map using `map->Type` +and implements IAssociative, ILookup and IObject." + :added "0.1"} + [nm field-syms & body] + (let [ctor-name (symbol (str "->" (name nm))) + map-ctor-name (symbol (str "map" (name ctor-name))) + fields (transduce (map (comp keyword name)) conj field-syms) + type-from-map `(defn ~map-ctor-name [m] + (apply ~ctor-name (map #(get m %) ~fields))) + default-bodies ['IAssociative + (-make-record-assoc-body ctor-name fields) + `(-contains-key [self k] + (contains? ~(set fields) k)) + `(-dissoc [self k] + (throw [:pixie.stdlib/NotImplementedException + "dissoc is not supported on defrecords"])) + 'ILookup + `(-val-at [self k not-found] + (if (contains? ~(set fields) k) + (. self k) + not-found)) + 'IObject + `(-str [self] + (str "<" ~(name nm) " " (reduce #(assoc %1 %2 (. self %2)) {} ~fields) ">")) + `(-eq [self other] + (and (instance? ~nm other) + ~@(map (fn [field] + `(= (. self ~field) (. other ~field))) + fields))) + `(-hash [self] + (hash [~@field-syms]))] + deftype-decl `(deftype ~nm ~fields ~@default-bodies ~@body)] + `(do ~type-from-map + ~deftype-decl))) + From 5df3dd15fc73f55a59de6bb5c217d8f07a9c5b61 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 16 Jun 2015 16:43:46 -0600 Subject: [PATCH 24/46] work on ns decls --- pixie/bootstrap.pxi | 136 +++++++++++++++++++++++++++++++++++++++ pixie/compiler.pxi | 9 +-- pixie/io-blocking.pxi | 23 +++++-- pixie/pxic-writer.pxi | 10 ++- pixie/vm2/interpreter.py | 60 ++++++++++++++++- pixie/vm2/keyword.py | 17 ++++- pixie/vm2/pxic_reader.py | 11 +++- pixie/vm2/rt.py | 4 ++ pixie/vm2/stdlib.py | 71 +++++++++++++++++++- pixie/vm2/string.py | 2 + pixie/vm2/symbol.py | 15 ++++- 11 files changed, 339 insertions(+), 19 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 5ecc268c..f2849335 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -197,6 +197,28 @@ (apply = y rest) false))) +(defn pos? + {:doc "Returns true if x is greater than zero" + :signatures [[x]] + :added "0.1"} + [x] + (> x 0)) + +(defn neg? + {:doc "Returns true if x is less than zero" + :signatures [[x]] + :added "0.1"} + [x] + (< x 0)) + +(defn zero? + {:doc "Returns true if x is equal to zero" + :signatures [[x]] + :added "0.1"} + [x] + (= x 0)) + + ;; Base functions (defn hash @@ -517,6 +539,26 @@ h1 (mix-h1 seed k1)] (fmix h1 4)))) +(defn hash-unencoded-chars [u] + (let [h1 (loop [i 1 + h1 seed] + (if (< i (count u)) + (let [k1 (bit-or (int (nth u (dec i))) + (int (nth u i))) + k1 (mix-k1 k1) + h1 (mix-h1 h1 k1)] + (recur (+ 2 i) + h1)) + h1)) + h1 (if (= (bit-and (count u) 1) 1) + (let [k1 (int (nth u (dec (count u)))) + k1 (mix-k1 k1) + _ (println h1 k1 (type h1) (type k1)) + h1 (bit-xor h1 k1)] + h1) + h1)] + (fmix h1 (* 2 (count u))))) + (in-ns :pixie.stdlib) ;; End Hashing Functions @@ -698,6 +740,19 @@ (defn counted? [v] (satisfies? ICounted v)) (defn vector? [v] (satisfies? IVector v)) +(defn int + {:doc "Converts a number to an integer." + :since "0.1"} + [x] + (cond + (integer? x) x + (float? x) (lround (floor x)) + (ratio? x) (int (/ (float (numerator x)) (float (denominator x)))) + (char? x) (-internal-int x) + :else (throw + [:pixie.stdlib/ConversionException + (throw (str "Can't convert a value of type " (type x) " to an Integer"))]))) + ;; End Type Checks @@ -1285,6 +1340,7 @@ INode (-assoc-inode [this shift hash-val key val added-leaf] + (println "inode " key val (hash key) (hash val) (= key val)) (let [bit (bitpos hash-val shift) idx (index this bit)] (if (not= (bit-and bitmap bit) 0) @@ -1575,6 +1631,37 @@ (extend -invoke PolymorphicFn -invoke) (extend -invoke DoublePolymorphicFn -invoke) +(extend -name Keyword -internal-get-name) +(extend -namespace Keyword -internal-get-ns) +(extend -hash Keyword (fn [x] + (println x) + (let [v (-internal-get-hash x)] + (if (zero? v) + (let [h (pixie.stdlib.hashing/hash-unencoded-chars (str x))] + (-internal-store-hash x h) + h) + v)))) + + + +(extend -name Symbol -internal-get-name) +(extend -namespace Symbol -internal-get-ns) +(extend -hash Symbol (fn [x] + (println x) + (let [v (-internal-get-hash x)] + (if (zero? v) + (let [h (pixie.stdlib.hashing/hash-unencoded-chars (str x))] + (-internal-store-hash x h) + h) + v)))) + +(extend -name String identity) +(extend -namespace String (fn [x] nil)) + + + + + ;(extend -reduce Cons seq-reduce) ;(extend -reduce PersistentList seq-reduce) ;(extend -reduce LazySeq seq-reduce) @@ -1625,6 +1712,55 @@ ;; End Extend Core Types +;; NS functions + +(defn refer + {:doc "Refer to the specified vars from a namespace directly. + +Supported filters: + :rename refer to the given vars under a different name + :exclude don't refer the given vars + :refer + :all refer all vars + :refer refer only the given vars + :only same as refer + +user => (refer 'pixie.string :refer :all) +user => (refer 'pixie.string :only '(index-of starts-with? ends-with?)) +user => (refer 'pixie.string :rename '{index-of find}) +user => (refer 'pixie.string :exclude '(substring))" + :added "0.1"} + [ns-sym & filters] + (let [ns (or (the-ns ns-sym) (throw [:pixie.stdlib/NamespaceNotFoundException + (str "No such namespace: " ns-sym)])) + filters (apply hashmap filters) + nsmap (ns-map ns) + rename (or (:rename filters) {}) + exclude (set (:exclude filters)) + refers (if (= :all (:refer filters)) + (keys nsmap) + (or (:refer filters) (:only filters)))] + (when (and refers (not (satisfies? ISeqable refers))) + (throw [:pixie.stdlib/InvalidArgumentException + ":only/:refer must be a collection of symbols"])) + (when-let [as (:as filters)] + (refer-ns *ns* ns-sym as)) + (loop [syms (seq refers)] + (if (not syms) + nil + (do + (let [sym (first syms)] + (when-not (exclude sym) + (let [v (nsmap sym)] + (when-not v + (throw [:pixie.stdlib/SymbolNotFoundException + (str sym "does not exist")])) + (refer-symbol *ns* (or (rename sym) sym) v)))) + (recur (next syms))))) + nil)) + + +;; End NS Functions ;; Multimethod stuff #_(comment diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 7104d849..ea305df9 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -216,12 +216,7 @@ (defmethod analyze-seq 'quote [[_ val]] - {:op :const - :type (cond - (symbol? val) :symbol - (string? val) :string - :else :unknown) - :form val}) + (->Const val *env*)) (defmethod analyze-seq 'in-ns [[_ nsp]] @@ -493,5 +488,7 @@ (dispose! os))) (time (compile-files ["pixie/bootstrap.pxi" + "pixie/streams.pxi" + "pixie/io-blocking.pxi" "pixie/reader.pxi"] "./bootstrap.pxic")) diff --git a/pixie/io-blocking.pxi b/pixie/io-blocking.pxi index ecfbd5ee..1e376832 100644 --- a/pixie/io-blocking.pxi +++ b/pixie/io-blocking.pxi @@ -1,6 +1,21 @@ (ns pixie.io-blocking - (:require [pixie.streams :as st :refer :all] - [pixie.io.common :as common])) + (:require [pixie.streams :as st :refer :all])) + + +(def DEFAULT-BUFFER-SIZE 1024) + +(defn stream-reducer [this f init] + (let [buf (buffer DEFAULT-BUFFER-SIZE) + rrf (preserving-reduced f)] + (loop [acc init] + (let [read-count (read this buf DEFAULT-BUFFER-SIZE)] + (if (> read-count 0) + (let [result (reduce rrf acc buf)] + (if (not (reduced? result)) + (recur result) + @result)) + acc))))) + (def fopen (ffi-fn libc "fopen" [CCharP CCharP] CVoidP)) @@ -36,7 +51,7 @@ (fclose fp)) IReduce (-reduce [this f init] - (common/stream-reducer this f init))) + (stream-reducer this f init))) (defn open-read {:doc "Open a file for reading, returning a IInputStream" @@ -129,7 +144,7 @@ (pclose fp)) IReduce (-reduce [this f init] - (common/stream-reducer this f init))) + (stream-reducer this f init))) (defn popen-read {:doc "Open a file for reading, returning a IInputStream" diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index 495d4cc9..e243765c 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -42,7 +42,8 @@ :META :LINE-META :VAR-CONST - :CHAR]) + :CHAR + :VECTOR]) (def *cache* nil) (set-dynamic! (var *cache*)) @@ -238,7 +239,12 @@ (write-object os ret) (write-meta os ast)) - + IVector + (-write-object [this os] + (write-tag os VECTOR) + (write-int-raw os (count this)) + (doseq [item this] + (write-object os item))) String (-write-object [this os] diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 319f332e..e6e3a954 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -83,6 +83,9 @@ def __init__(self, val, meta=nil): def interpret(self, _, locals, stack): return self._c_val, stack + def gather_locals(self): + return {} + @expose("_c_value", "_c_name", "_c_next") class Locals(object): _immutable_ = True @@ -92,6 +95,8 @@ def __init__(self, name, value, next): self._c_name = name self._c_next = next + + @staticmethod @jit.unroll_safe def get_local(self, name): @@ -112,6 +117,8 @@ def __init__(self, name, meta=nil): def interpret(self, _, locals, stack): return Locals.get_local(locals, self._c_name), stack + def gather_locals(self): + return {self._c_name: self._c_name} class Fn(AST): _immutable_fields_ = ["_c_name", "_c_args", "_c_body", "_c_closed_overs"] @@ -120,7 +127,22 @@ def __init__(self, name, args, body, closed_overs=[], meta=nil): self._c_name = name self._c_args = args self._c_body = body - self._c_closed_overs = closed_overs + + glocals = self._c_body.gather_locals() + for x in self._c_args: + if x in glocals: + del glocals[x] + + self._c_closed_overs = list(glocals.iterkeys()) + + def gather_locals(self): + glocals = {} + + for x in self._c_closed_overs: + glocals[x] = x + + return glocals + @jit.unroll_safe def interpret(self, _, locals, stack): @@ -169,6 +191,13 @@ def __init__(self, args, meta=nil): AST.__init__(self, meta) self._c_args = args + def gather_locals(self): + glocals = {} + for x in self._c_args: + glocals = merge_dicts(glocals, x.gather_locals()) + + return glocals + def interpret(self, _, locals, stack): stack = stack_cons(stack, InvokeK(self)) stack = stack_cons(stack, ResolveAllK(self._c_args, locals, [])) @@ -247,6 +276,14 @@ def __init__(self, names, bindings, body, meta=nil): self._c_bindings = bindings self._c_body = body + def gather_locals(self): + glocals = {} + for x in self._c_bindings: + glocals = merge_dicts(glocals, x.gather_locals()) + + glocals = merge_dicts(glocals, self._c_body.gather_locals()) + return glocals + def interpret(self, _, locals, stack): stack = stack_cons(stack, LetK(self, 0, locals)) stack = stack_cons(stack, InterpretK(self._c_bindings[0], locals)) @@ -288,6 +325,12 @@ def interpret(self, val, locals, stack): stack = stack_cons(stack, InterpretK(self._c_test, locals)) return nil, stack + def gather_locals(self): + glocals = self._c_test.gather_locals() + glocals = merge_dicts(glocals, self._c_then.gather_locals()) + glocals = merge_dicts(glocals, self._c_else.gather_locals()) + return glocals + class IfK(Continuation): _immutable_ = True def __init__(self, ast, locals): @@ -317,6 +360,13 @@ def __init__(self, args, meta=nil): def interpret(self, val, locals, stack): return nil, stack_cons(stack, DoK(self, self._c_body_asts, locals)) + def gather_locals(self): + glocals = {} + for x in self._c_body_asts: + glocals = merge_dicts(glocals, x.gather_locals()) + + return glocals + class DoK(Continuation): _immutable_ = True @@ -348,6 +398,9 @@ def __init__(self, var, meta=nil): def interpret(self, val, locals, stack): return self._c_var.deref(), stack + def gather_locals(self): + return {} + from rpython.rlib.jit import JitDriver from rpython.rlib.objectmodel import we_are_translated @@ -501,6 +554,11 @@ def slice_stack(self, orig_stack, handler): return stack, slice +def merge_dicts(a, b): + z = a.copy() + z.update(b) + return z + diff --git a/pixie/vm2/keyword.py b/pixie/vm2/keyword.py index 469315bc..4fd2a397 100644 --- a/pixie/vm2/keyword.py +++ b/pixie/vm2/keyword.py @@ -5,7 +5,7 @@ from pixie.vm.code import extend, as_var import pixie.vm.rt as rt #import pixie.vm.util as util -from rpython.rlib.rarithmetic import intmask +from rpython.rlib.rarithmetic import intmask, r_uint class Keyword(Object): @@ -14,7 +14,7 @@ def __init__(self, name): self._str = name self._w_name = None self._w_ns = None - self._hash = 0 + self._hash = r_uint(0) def type(self): return Keyword._type @@ -35,6 +35,19 @@ def init_names(self): def __repr__(self): return u":" + self._str + def to_str(self): + return u":" + self._str + + def to_repr(self): + return u":" + self._str + + def store_hash(self, hash): + self._hash = hash + + def get_hash(self): + return self._hash + + class KeywordCache(object): def __init__(self): diff --git a/pixie/vm2/pxic_reader.py b/pixie/vm2/pxic_reader.py index 1226bb48..decb60a5 100644 --- a/pixie/vm2/pxic_reader.py +++ b/pixie/vm2/pxic_reader.py @@ -58,7 +58,8 @@ def get_cache(self, idx): "META", "LINE_META", "VAR_CONST", - "CHAR"] + "CHAR", + "VECTOR"] for idx, x in enumerate(bytecodes): globals()[x] = idx @@ -222,6 +223,14 @@ def read_object(os): str = read_raw_string(os) return char_cache.intern(ord(str[0])) + elif tag == VECTOR: + cnt = read_raw_int(os) + lst = [None] * cnt + for x in range(cnt): + lst[x] = read_object(os) + + return Array(lst) + raise AssertionError("No valid handler for TAG " + bytecodes[tag]) diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index b2aa2694..afb207d1 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -151,6 +151,10 @@ def int_val(x): def unwrap_string(x): from pixie.vm2.string import String from pixie.vm2.object import affirm + from pixie.vm2.primitives import nil + + if x is None or x is nil: + return None affirm(isinstance(x, String), u"Expected String") assert isinstance(x, String) diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 3ba1482f..3e7f54a7 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -162,6 +162,34 @@ def _internal_to_str(x): def _internal_to_repr(x): return rt.wrap(x.to_repr()) +@as_var("-internal-get-ns") +def _internal_get_ns(x): + return rt.wrap(x.get_ns()) + +@as_var("-internal-get-name") +def _internal_get_name(x): + return rt.wrap(x.get_name()) + +@as_var("-internal-get-hash") +def _internal_get_name(x): + return rt.wrap(x.get_hash()) + + +@as_var("-internal-store-hash") +def _internal_store_hash(x, h): + x.store_hash(h.r_uint_val()) + return nil + +@as_var("-internal-int") +def _internal_int(x): + return rt.wrap(x.int_val()) + +@as_var("-internal-set-hash") +def _internal_sett_hash(x, hash_val): + x.set_hash(hash_val.int_val()) + return x + + @as_var("-blocking-println") def _blocking_println(x): print rt.unwrap_string(x) @@ -193,4 +221,45 @@ def size_t(i): @as_var("type") def type(x): - return x.type() \ No newline at end of file + return x.type() + + +@as_var("the-ns") +def the_ns(ns_name): + affirm(ns_name.get_ns() is None, u"the-ns takes a un-namespaced symbol") + + return code._ns_registry.get(ns_name.get_name(), nil) + + +@as_var("load-ns") +def load_ns(filename): + import pixie.vm2.string as string + import pixie.vm2.symbol as symbol + import os.path as path + + if isinstance(filename, symbol.Symbol): + affirm(filename.get_ns() is None, u"load-file takes a un-namespaced symbol") + filename_str = filename.get_name().replace(u".", u"/") + u".pxi" + + loaded_ns = code._ns_registry.get(filename.get_name(), None) + if loaded_ns is not None: + return loaded_ns + else: + affirm(isinstance(filename, string.String), u"Filename must be string") + filename_str = filename.get_name + + paths = rt.deref(rt.deref(rt.load_paths)) + f = None + for x in range(rt.count(paths)): + path_x = rt.nth(paths, rt.wrap(x)) + affirm(isinstance(path_x, string.String), u"Contents of load-paths must be strings") + full_path = path.join(str(rt.name(path_x)), str(filename_str)) + if path.isfile(full_path): + f = full_path + break + + if f is None: + affirm(False, u"File '" + rt.name(filename) + u"' does not exist in any directory found in load-paths") + else: + rt.load_file(rt.wrap(f)) + return nil \ No newline at end of file diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index 2b4bcf02..8c90ecdb 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -103,6 +103,8 @@ def __init__(self, i): def char_val(self): return self._char_val + def int_val(self): + return self._char_val def to_str(self): assert isinstance(self, Character) diff --git a/pixie/vm2/symbol.py b/pixie/vm2/symbol.py index 94e0586b..a22da332 100644 --- a/pixie/vm2/symbol.py +++ b/pixie/vm2/symbol.py @@ -4,7 +4,7 @@ from pixie.vm2.string import String import pixie.vm2.rt as rt #import pixie.vm2.util as util -from rpython.rlib.rarithmetic import intmask +from rpython.rlib.rarithmetic import intmask, r_uint class Symbol(object.Object): @@ -14,7 +14,7 @@ def __init__(self, s, meta=nil): self._str = s self._w_name = None self._w_ns = None - self._hash = 0 + self._hash = r_uint(0) self._meta = meta def type(self): @@ -48,6 +48,17 @@ def get_ns(self): return rt.unwrap_string(self._w_ns) + def to_str(self): + return self._str + + def to_repr(self): + return self._str + + def store_hash(self, hash): + self._hash = hash + + def get_hash(self): + return self._hash def symbol(s): return Symbol(s) From 37099afe1f51f941e66a52b178582bf1603f77bd Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 22 Jun 2015 22:38:26 -0600 Subject: [PATCH 25/46] ffi works, can slurp a file via blocking io --- Makefile | 4 +- pixie/bootstrap.pxi | 101 +++-- pixie/compiler.pxi | 96 ++-- pixie/pxic-writer.pxi | 32 +- pixie/stdlib.pxi | 21 +- pixie/vm2/code.py | 124 +++++- pixie/vm2/ffi.py | 934 +++++++++++++++++++++++++++++++++++++++ pixie/vm2/interpreter.py | 30 +- pixie/vm2/keyword.py | 12 +- pixie/vm2/object.py | 16 +- pixie/vm2/platform.py | 23 + pixie/vm2/pxic_reader.py | 5 +- pixie/vm2/rt.py | 22 +- pixie/vm2/stdlib.py | 89 +++- pixie/vm2/string.py | 8 + 15 files changed, 1325 insertions(+), 192 deletions(-) create mode 100644 pixie/vm2/ffi.py create mode 100644 pixie/vm2/platform.py diff --git a/Makefile b/Makefile index 1edafcbd..d3c02278 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ all: help EXTERNALS=externals -PYTHON ?= pypy +PYTHON ?= python PYTHONPATH=$$PYTHONPATH:$(EXTERNALS)/pypy @@ -66,7 +66,7 @@ run: run_interactive: - @PYTHONPATH=$(PYTHONPATH) $(PYTHON) target.py + @PYTHONPATH=$(PYTHONPATH) $(PYTHON) target.py pixie/compiler.pxi run_interactive2: @PYTHONPATH=$(PYTHONPATH) pypy target2.py diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index f2849335..5d9231d8 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -99,6 +99,7 @@ (-effect-val [this v]) (-effect-return [this v])) +(-run-external-extends) (extend -get-field Object -internal-get-field) @@ -307,6 +308,19 @@ ([coll idx] (-nth coll idx)) ([coll idx not-found] (-nth-not-found coll idx not-found))) +(defn name + [x] (-name x)) + +(defn namespace + [x] (-namespace x)) + + +(defn dispose! + "Finalizes use of the object by cleaning up resources used by the object" + [x] + (-dispose! x) + nil) + (defn has-meta? [x] @@ -346,7 +360,6 @@ (-apply f arg-array))) (defn last [coll] - (println "LAST " (type coll)) (if (vector? coll) (nth coll (dec (count coll))) (loop [coll coll] @@ -422,7 +435,7 @@ ([sb] (-internal-to-str sb)) ([sb x] (if (instance? String x) - (-add-to-string-builder x) + (-add-to-string-builder sb x) (-str x (fn [x] (-add-to-string-builder sb x)))))) @@ -553,7 +566,6 @@ h1 (if (= (bit-and (count u) 1) 1) (let [k1 (int (nth u (dec (count u)))) k1 (mix-k1 k1) - _ (println h1 k1 (type h1) (type k1)) h1 (bit-xor h1 k1)] h1) h1)] @@ -1340,7 +1352,6 @@ INode (-assoc-inode [this shift hash-val key val added-leaf] - (println "inode " key val (hash key) (hash val) (= key val)) (let [bit (bitpos hash-val shift) idx (index this bit)] (if (not= (bit-and bitmap bit) 0) @@ -1634,7 +1645,6 @@ (extend -name Keyword -internal-get-name) (extend -namespace Keyword -internal-get-ns) (extend -hash Keyword (fn [x] - (println x) (let [v (-internal-get-hash x)] (if (zero? v) (let [h (pixie.stdlib.hashing/hash-unencoded-chars (str x))] @@ -1642,12 +1652,17 @@ h) v)))) +(extend -invoke Keyword (fn + ([this o] + (-get o this nil)) + ([this o not-found] + (-get o this not-found)))) + (extend -name Symbol -internal-get-name) (extend -namespace Symbol -internal-get-ns) (extend -hash Symbol (fn [x] - (println x) (let [v (-internal-get-hash x)] (if (zero? v) (let [h (pixie.stdlib.hashing/hash-unencoded-chars (str x))] @@ -1668,7 +1683,22 @@ -;(extend -reduce Buffer indexed-reduce) +;; Buffer + +(extend -reduce Buffer + (fn [b f init] + (loop [idx 0 + acc init] + (if (reduced? acc) + @acc + (if (< idx (count b)) + (let [val (pixie.ffi/unpack b idx CUInt8)] + (recur (inc idx) + (f acc val))) + acc))))) + +;; + (extend -str Bool (fn [x sb] @@ -1730,33 +1760,28 @@ user => (refer 'pixie.string :only '(index-of starts-with? ends-with?)) user => (refer 'pixie.string :rename '{index-of find}) user => (refer 'pixie.string :exclude '(substring))" :added "0.1"} - [ns-sym & filters] + [from-ns ns-sym & filters] + (println ns-sym) (let [ns (or (the-ns ns-sym) (throw [:pixie.stdlib/NamespaceNotFoundException (str "No such namespace: " ns-sym)])) filters (apply hashmap filters) - nsmap (ns-map ns) rename (or (:rename filters) {}) - exclude (set (:exclude filters)) - refers (if (= :all (:refer filters)) - (keys nsmap) - (or (:refer filters) (:only filters)))] - (when (and refers (not (satisfies? ISeqable refers))) - (throw [:pixie.stdlib/InvalidArgumentException - ":only/:refer must be a collection of symbols"])) - (when-let [as (:as filters)] - (refer-ns *ns* ns-sym as)) - (loop [syms (seq refers)] - (if (not syms) - nil - (do - (let [sym (first syms)] - (when-not (exclude sym) - (let [v (nsmap sym)] - (when-not v - (throw [:pixie.stdlib/SymbolNotFoundException - (str sym "does not exist")])) - (refer-symbol *ns* (or (rename sym) sym) v)))) - (recur (next syms))))) + exclude (:exclude filters) + rname (or (:as filters) + ns-sym)] + (println "refering " from-ns ns-sym) + (-add-refer from-ns ns-sym rname) + (if (= :all (:refer filters)) + (-refer-all from-ns rname) + (doseq [sym (:refer filters)] + (-add-refer from-ns rname sym sym))) + + (doseq [[from to] (:rename filters)] + (-add-refer from-ns rname from to)) + + (doseq [nm (:exclude filters)] + (-add-exclude from-ns rname nm)) + nil)) @@ -1818,4 +1843,20 @@ user => (refer 'pixie.string :exclude '(substring))" ;; End Multimethods +;; LibC Stuff +(def load-paths (atom ["." ""])) + +(defn ffi-library [nm] + (reduce + (fn [_ x] + (when-let [l (-ffi-library (str x (name nm)))] + (reduced l))) + nil + @load-paths)) + + +(def libc (ffi-library pixie.platform/lib-c-name)) + + +;; diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index ea305df9..061abc27 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -56,7 +56,7 @@ body) proto-bodies (second bodies) all-fields fields - type-nm (str (:ns *env*) "." (name nm)) + type-nm (str @(:ns *env*) "." (name nm)) type-decl `(def ~nm (create-type ~(keyword type-nm) ~all-fields)) inst (gensym) @@ -68,14 +68,38 @@ (cond (symbol? body) `(satisfy ~body ~nm) (seq? body) `(extend ~(first body) - ~(symbol (str (:ns *env*) "/" nm)) + ~(symbol (str @(:ns *env*) "/" nm)) ~(mk-body body)) :else (assert false "Unknown body element in deftype, expected symbol or seq")))) conj proto-bodies)] `(do ~type-decl ~ctor - ~@proto-bodies)))}) + ~@proto-bodies))) + + (resolve 'ns) + (fn ns [nm & body] + (let [bmap (reduce (fn [m b] + (update-in m [(first b)] (fnil conj []) (rest b))) + {} + body) + requires + (do + (assert (>= 1 (count (:require bmap))) + "Only one :require block can be defined per namespace") + (mapv (fn [r] `(require ~(keyword (name nm)) ~@r)) (first (:require bmap))))] + `(do (in-ns ~(keyword (name nm))) + (println "in-ns " ~(keyword (name nm))) + ~@requires))) + + (resolve 'require) + (fn [ins ns & args] + `(do (load-ns (quote ~ns)) + (assert (the-ns (quote ~ns)) + (str "Couldn't find the namespace " (quote ~ns) " after loading the file")) + + (apply refer ~ins (quote [~ns ~@args])))) + }) (def *env* nil) @@ -206,8 +230,6 @@ (defmethod analyze-seq 'def [[_ nm val :as form]] - (swap! (:vars *env*) update-in [(:ns *env*) nm] (fn [x] - (or x :def))) (->Def nm (analyze-form val) @@ -220,10 +242,10 @@ (defmethod analyze-seq 'in-ns [[_ nsp]] - (set! (var *env*) (assoc *env* :ns (symbol (name nsp)))) + (reset! (:ns *env*) (symbol (name nsp))) (in-ns nsp) (in-ns :pixie.compiler) - (analyze-form nil)) + (analyze-form (list 'pixie.stdlib/-in-ns (keyword (name nsp))))) (defmethod analyze-seq 'local-macro [[_ [nm replace] & body :as form]] @@ -251,7 +273,7 @@ (defmethod analyze-seq :default [[sym & args :as form]] (let [resolved (try (and (symbol? sym) - (resolve-in (the-ns (:ns *env*)) sym)) + (resolve-in (the-ns @(:ns *env*)) sym)) (catch :pixie.stdlib/AssertionException ex nil))] (cond @@ -316,43 +338,7 @@ *env*)) (defn maybe-var [x] - (let [namesp (the-ns (:ns *env*)) - resolved (try - (resolve-in namesp x) - (catch :pixie.stdlib/AssertionException ex - nil)) - result (cond - (namespace x) - (->Var (symbol (namespace x)) - (symbol (name x)) - x - *env*) - - (get-in @(:vars *env*) [(:ns *env*) x]) - (->Var (:ns *env*) - x - x - *env*) - - ;; Hack until we get proper refers - (get-in @(:vars *env*) ['pixie.stdlib x]) - (->Var 'pixie.stdlib - x - x - *env*) - - resolved - (->Var (namespace resolved) - (name resolved) - x - *env*) - - :else - (->Var (name (:ns *env*)) - (name x) - x - *env*))] - result)) + (->Var @(:ns *env*) x x *env*)) ;; ENV Functions @@ -361,16 +347,11 @@ "Creates a new (empty) environment" [] (->Env - 'pixie.stdlib - (atom {'pixie.stdlib {'array true - 'size-t true - 'bit-count32 true - 'contains-table true - 'switch-table true - '-add-to-string-builder true - '-parse-number true}}) + (atom 'pixie.stdlib) + nil {} - true)) + true + nil)) (defn analyze @@ -462,14 +443,14 @@ (println "done"))) (defn compile-file [from os] - (let [forms (read-string (str "[" (io/slurp from) "]")) + (let [forms (read-string (str "[" (io/slurp from) "]") from) form-count (atom 0) total-count (atom 0)] (doseq [form forms] (swap! form-count inc) (swap! total-count inc) (when (= @form-count 10) - (println from (int (* 100 (/ @total-count (count forms)))) "% in" (:ns *env*)) + (println from (int (* 100 (/ @total-count (count forms)))) "% in" @(:ns *env*)) (reset! form-count 0)) (let [ast (read-and-compile form env)] @@ -490,5 +471,6 @@ (time (compile-files ["pixie/bootstrap.pxi" "pixie/streams.pxi" "pixie/io-blocking.pxi" - "pixie/reader.pxi"] + "pixie/reader.pxi" + "pixie/main.pxi"] "./bootstrap.pxic")) diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index e243765c..c549bb36 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -75,10 +75,10 @@ (defn writer-cache [os] (->WriterCache os {})) -(defn write-raw-string [os str] - (assert (string? str) "Expected String") - (write-int-raw os (count str)) - (spit os str false)) +(defn write-raw-string [os s] + (assert (string? s) (str "Expected String, got " str)) + (write-int-raw os (count s)) + (spit os s false)) (defn write-int-raw [os i] (if (<= 0 i MAX_INT32) @@ -98,8 +98,9 @@ (defn write-meta [os ast] (let [m (or (meta (:form ast)) + (:meta (:env ast)) *old-meta*)] - (if m + (if (and m (:file m)) (write-object os (ast/->Meta (ast/->LineMeta (str (:line m)) @@ -213,19 +214,17 @@ (write-raw-string os (str name))))) ast/Var - (-write-object [{:keys [ns name]} os] - (write-cached-obj *cache* - [:deref ns name] - (fn [_ ns name] - (write-tag os VAR) - (write-raw-string os (str ns)) - (write-raw-string os (str name))))) + (-write-object [{:keys [ns var-name] :as ast} os] + (write-tag os VAR) + (write-raw-string os (str ns)) + (write-object os var-name) + (write-meta os ast)) ast/Invoke - (-write-object [{:keys [fn args] :as ast} os] + (-write-object [{:keys [args] :as ast} os] (write-tag os INVOKE) (write-int-raw os (inc (count args))) - (write-object os fn) + (write-object os (:fn ast)) (doseq [arg args] (write-object os arg)) (write-meta os ast)) @@ -307,7 +306,8 @@ (defn write-object [os ast] (binding [*old-meta* (or (and - (map? ast) - (meta (:form ast))) + (satisfies? ast/IAst ast) + (or (meta (:form ast)) + (:meta (:env ast)))) *old-meta*)] (-write-object (simplify ast) os))) diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index 7cf1d242..3a1d0ca9 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -305,7 +305,7 @@ (comment (extend -reduce Array indexed-reduce)) (extend -reduce Buffer indexed-reduce) -#_(extend -reduce String indexed-reduce) +(extend -reduce String indexed-reduce) (extend -str Bool (fn [x] @@ -1311,11 +1311,12 @@ Creates new maps if the keys are not present." (assert (= (count binding) 2) "expected a binding and a collection") (let [b (first binding) s (second binding)] - `(loop [s# (seq ~s)] - (if s# - (let [~b (first s#)] - ~@body - (recur (next s#))))))) + `(reduce + (fn [acc# ~b] + ~@body + nil) + nil + ~s))) (defmacro doc {:doc "Returns the documentation of the given value." @@ -2448,14 +2449,6 @@ Calling this function on something that is not ISeqable returns a seq with that (extend -persistent! PersistentHashMap identity) -(extend -persistent! DictMap dict-map-to-phm) -(extend -assoc DictMap add-to-dict-map) -(extend -conj DictMap (fn [m [k v]] - (assoc m k v))) -(extend -conj! DictMap (fn [m [k v]] - (assoc m k v))) -(extend -val-at DictMap (fn [m k _] - (get-from-dict-map m k))) (extend -str Namespace (fn [v] (str ""))) diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index ff08e989..0763ca22 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -503,10 +503,32 @@ def __exit__(self, exc_type, exc_val, exc_tb): class Refer(py_object): - def __init__(self, ns, refer_syms=[], refer_all=False): + def __init__(self, ns, refer_syms={}, refer_all=False): self._namespace = ns self._refer_syms = refer_syms self._refer_all = refer_all + self._excludes = {} + + def refer_all(self): + self._refer_all = True + + def add_var_alias(self, old, new): + assert isinstance(old, unicode) + assert isinstance(new, unicode) + + self._refer_syms[new] = old + + def add_var_exclude(self, old): + self._excludes[old] = old + + def find_var(self, name): + if self._refer_all and name not in self._excludes: + return self._namespace.resolve_in_ns(name, False) + else: + other = self._refer_syms.get(name, None) + if other: + return self._namespace.resolve_in_ns(other, False) + return None class Namespace(object.Object): @@ -519,9 +541,16 @@ def __init__(self, name): self._registry = {} self._name = name self._refers = {} + self._var_cache = {} + self._rev = 0 + + def reset_cache(self): + self._var_cache.clear() + self._rev += 1 def intern_or_make(self, name): assert name is not None + self.reset_cache() affirm(isinstance(name, unicode), u"Var names must be unicode") v = self._registry.get(name, None) if v is None: @@ -531,6 +560,8 @@ def intern_or_make(self, name): def add_refer(self, ns, as_nm=None, refer_all=False): assert isinstance(ns, Namespace) + self.reset_cache() + if as_nm is not None: assert isinstance(as_nm, unicode) @@ -539,8 +570,14 @@ def add_refer(self, ns, as_nm=None, refer_all=False): self._refers[as_nm] = Refer(ns, refer_all=refer_all) + def get_refer(self, nm): + assert isinstance(nm, unicode) + + return self._refers.get(nm, None) + def add_refer_symbol(self, sym, var): assert isinstance(self, Namespace) + self.reset_cache() name = rt.name(sym) prev_binding = self._registry.get(name, None) @@ -551,14 +588,16 @@ def add_refer_symbol(self, sym, var): return var def include_stdlib(self): - stdlib = _ns_registry.find_or_make(u"pixie.stdlib") + stdlib = ns_registry.find_or_make(u"pixie.stdlib") self.add_refer(stdlib, refer_all=True) + self.reset_cache() + def resolve(self, s, use_refers=True): import pixie.vm2.symbol as symbol affirm(isinstance(s, symbol.Symbol), u"Must resolve symbols") - ns = rt.namespace(s) - name = rt.name(s) + ns = s.get_ns() + name = s.get_name() if ns is not None: refer = self._refers.get(ns, None) @@ -566,7 +605,7 @@ def resolve(self, s, use_refers=True): if refer is not None: resolved_ns = refer._namespace if resolved_ns is None: - resolved_ns = _ns_registry.get(ns, None) + resolved_ns = ns_registry.get(ns, None) if resolved_ns is None: affirm(False, u"Unable to resolve namespace: " + ns + u" inside namespace " + self._name) else: @@ -574,15 +613,44 @@ def resolve(self, s, use_refers=True): assert isinstance(resolved_ns, Namespace) - var = resolved_ns._registry.get(name, None) - if var is None and use_refers: - for refer_nm in self._refers: - refer = self._refers[refer_nm] - if name in refer._refer_syms or refer._refer_all: - var = refer._namespace.resolve(symbol.Symbol(name), False) - if var is not None: - return var - return None + return resolved_ns.resolve_in_ns(name, use_refers=use_refers) + + def resolve_in_ns_ex(self, ns, name, use_refers=True): + return self._resolve_in_ns_ex(ns, name, self._rev, use_refers) + + @jit.elidable_promote() + def _resolve_in_ns_ex(self, ns, name, rev, use_refers): + if ns is None: + return self._resolve_in_ns(name, use_refers, rev) + else: + refer = self._refers.get(ns, None) + if refer is not None: + return refer._namespace._resolve_in_ns(name, use_refers, rev) + else: + resolved_ns = ns_registry.get(ns, None) + if resolved_ns is None: + return None + return resolved_ns.resolve_in_ns(name, False) + + def resolve_in_ns(self, name, use_refers=True): + return self._resolve_in_ns(name, use_refers, self._rev) + + + @jit.elidable_promote() + def _resolve_in_ns(self, name, use_refers, rev): + var = self._var_cache.get(name, None) + if var is None: + var = self._registry.get(name, None) + if var is None and use_refers: + for refer_nm in self._refers: + refer = self._refers[refer_nm] + var = refer.find_var(name) + if var is not None: + break + + if var is not None: + self._var_cache[name] = var + return var def get(self, name, default): @@ -599,12 +667,13 @@ def find_or_make(self, name): if v is None: v = Namespace(name) self._registry[name] = v + v.include_stdlib() return v def get(self, name, default): return self._registry.get(name, default) -_ns_registry = NamespaceRegistry() +ns_registry = NamespaceRegistry() def intern_var(ns, name=None): @@ -612,11 +681,11 @@ def intern_var(ns, name=None): name = ns ns = u"" - return _ns_registry.find_or_make(ns).intern_or_make(name) + return ns_registry.find_or_make(ns).intern_or_make(name) def get_var_if_defined(ns, name, els=None): - w_ns = _ns_registry.get(ns, None) + w_ns = ns_registry.get(ns, None) if w_ns is None: return els return w_ns.get(name, els) @@ -910,6 +979,27 @@ def extend_inner(fn): return extend_inner +init_ctx = [] + +def extend_var(ns_name, var_name, tp1): + if isinstance(tp1, type): + assert_tp = tp1 + tp1 = tp1._type + else: + assert_tp = object.Object + + var = intern_var(unicode(ns_name), unicode(var_name)) + + def extend_inner(fn): + init_ctx.append((var, tp1, wrap_fn(fn, assert_tp))) + + return var + + return extend_inner + + + + def as_var(ns, name=None): """Locates a var with the given name (defaulting to the namespace pixie.stdlib), sets diff --git a/pixie/vm2/ffi.py b/pixie/vm2/ffi.py new file mode 100644 index 00000000..9dcd868d --- /dev/null +++ b/pixie/vm2/ffi.py @@ -0,0 +1,934 @@ +py_object = object +import rpython.rlib.rdynload as dynload +import pixie.vm2.object as object +from pixie.vm2.object import runtime_error +from pixie.vm2.keyword import Keyword +import pixie.vm2.stdlib as proto +from pixie.vm2.code import as_var, affirm, extend_var, wrap_fn, intern_var +import pixie.vm2.rt as rt +from rpython.rtyper.lltypesystem import rffi, lltype, llmemory +from pixie.vm2.primitives import nil, true, false +from pixie.vm2.numbers import Integer, Float +from pixie.vm2.string import String +from pixie.vm2.keyword import Keyword +from rpython.rlib import clibffi +from rpython.rlib.jit_libffi import jit_ffi_call, CIF_DESCRIPTION, CIF_DESCRIPTION_P, \ + FFI_TYPE_P, FFI_TYPE_PP, SIZE_OF_FFI_ARG +import rpython.rlib.jit_libffi as jit_libffi +from rpython.rlib.objectmodel import keepalive_until_here, we_are_translated +import rpython.rlib.jit as jit +from rpython.rlib.rarithmetic import intmask + + +""" +FFI interface for pixie. + +This code gets a bit interesting. We use the RPython rlib module jit_libffi to do the interfacing, you can find +good docs in that module. + +""" + + +class CType(object.Type): + def __init__(self, name): + object.Type.__init__(self, name) + + +load_paths = intern_var(u"pixie.stdlib", u"load-paths") + +class ExternalLib(object.Object): + _type = object.Type(u"pixie.stdlib.ExternalLib") + + def type(self): + return ExternalLib._type + + def __init__(self, nm): + assert isinstance(nm, unicode) + self._name = nm + self._is_inited = False + self.load_lib() + + def load_lib(self): + if not self._is_inited: + s = rffi.str2charp(str(self._name)) + try: + self._dyn_lib = dynload.dlopen(s) + self._is_inited = True + finally: + rffi.free_charp(s) + + + def get_fn_ptr(self, nm): + assert isinstance(nm, unicode) + s = rffi.str2charp(str(nm)) + sym = dynload.dlsym(self._dyn_lib, s) + rffi.free_charp(s) + return sym + +@as_var("-ffi-library") +def _ffi_library(ns): + try: + return ExternalLib(ns.get_name()) + except dynload.DLOpenError as ex: + return nil + +class FFIFn(object.Object): + _type = object.Type(u"pixie.stdlib.FFIFn") + _immutable_fields_ = ["_is_inited", "_lib", "_name", "_arg_types[*]", "_arity", "_ret_type", "_is_variadic", \ + "_transfer_size", "_arg0_offset", "_ret_offset", "_cd"] + + def type(self): + return FFIFn._type + + def __init__(self, lib, name, arg_types, ret_type, is_variadic): + self._rev = 0 + self._name = name + self._lib = lib + self._arg_types = arg_types + self._arity = len(arg_types) + self._ret_type = ret_type + self._is_variadic = is_variadic + self._f_ptr = self._lib.get_fn_ptr(self._name) + self._cd = CifDescrBuilder(self._arg_types, self._ret_type).rawallocate() + + @jit.unroll_safe + def prep_exb(self, args): + size = jit.promote(self._cd.exchange_size) + exb = rffi.cast(rffi.VOIDP, lltype.malloc(rffi.CCHARP.TO, size, flavor="raw")) + tokens = [None] * len(args) + + for i, tp in enumerate(self._arg_types): + offset_p = rffi.ptradd(exb, jit.promote(self._cd.exchange_args[i])) + tokens[i] = tp.ffi_set_value(offset_p, args[i]) + + return exb, tokens + + def get_ret_val_from_buffer(self, exb): + offset_p = rffi.ptradd(exb, jit.promote(self._cd.exchange_result)) + ret_val = self._ret_type.ffi_get_value(offset_p) + return ret_val + + @jit.unroll_safe + def _invoke(self, args): + arity = len(args) + if self._is_variadic: + if arity < self._arity: + runtime_error(u"Wrong number of args to fn: got " + unicode(str(arity)) + + u", expected at least " + unicode(str(self._arity))) + else: + if arity != self._arity: + runtime_error(u"Wrong number of args to fn: got " + unicode(str(arity)) + + u", expected " + unicode(str(self._arity))) + + exb, tokens = self.prep_exb(args) + cd = jit.promote(self._cd) + #fp = jit.promote(self._f_ptr) + jit_ffi_call(cd, + self._f_ptr, + exb) + ret_val = self.get_ret_val_from_buffer(exb) + + for x in range(len(args)): + t = tokens[x] + if t is not None: + t.finalize_token() + + lltype.free(exb, flavor="raw") + keepalive_until_here(args) + return ret_val + + def invoke_k(self, args, stack): + print "Invoking ", self._name + self = jit.promote(self) + return self._invoke(args), stack + + + +@as_var("ffi-fn") +def _ffi_fn__args(args): + from pixie.vm2.array import Array + + affirm(len(args) >= 4, u"ffi-fn requires at least 4 arguments") + lib, nm, arg_types, ret_type = args[:4] + + affirm(isinstance(lib, ExternalLib), u"First argument must be an ExternalLib") + affirm(isinstance(ret_type, object.Type), u"Ret type must be a type") + affirm(nm.get_ns() is None, u"Name must not be namespaced") + affirm(isinstance(arg_types, Array), u"Arguments must be in an array") + assert isinstance(arg_types, Array) + + new_args = arg_types._list + + kwargs = args[4:] + affirm(len(kwargs) & 0x1 == 0, u"ffi-fn requires even number of options") + + is_variadic = False + for i in range(0, len(kwargs)/2, 2): + key = kwargs[i] + val = kwargs[i+1] + + affirm(isinstance(key, Keyword), u"ffi-fn options should be keyword/bool pairs") + affirm(val is true or val is false, u"ffi-fn options should be keyword/bool pairs") + + k = key.get_name() + if k == u"variadic?": + is_variadic = True if val is true else False + else: + affirm(False, u"unknown ffi-fn option: :" + k) + + f = FFIFn(lib, nm.get_name(), new_args, ret_type, is_variadic) + return f + +@as_var("ffi-voidp") +def _ffi_voidp(lib, nm): + affirm(isinstance(lib, ExternalLib), u"First argument to ffi-voidp should be an external library") + name = nm.get_name() + return VoidP(lib.get_fn_ptr(name)) + + + + + + + +class Buffer(object.Object): + """ Defines a byte buffer with non-gc'd (therefore non-movable) contents + """ + _type = object.Type(u"pixie.stdlib.Buffer") + + def type(self): + return Buffer._type + + def __init__(self, size): + self._size = size + self._used_size = 0 + self._buffer = lltype.malloc(rffi.CCHARP.TO, size, flavor="raw") + + + def __del__(self): + #lltype.free(self._buffer, flavor="raw") + pass + + def set_used_size(self, size): + self._used_size = size + + def buffer(self): + return self._buffer + + def raw_data(self): + return rffi.cast(rffi.VOIDP, self._buffer) + + def count(self): + return self._used_size + + def nth_char(self, idx): + assert isinstance(idx, int) + return self._buffer[idx] + + def capacity(self): + return self._size + + def free_data(self): + lltype.free(self._buffer, flavor="raw") + + +# +# @extend(proto._dispose_BANG_, Buffer) +# def _dispose_voidp(self): +# self.free_data() +# +# +# @extend(proto._nth, Buffer) +# def _nth(self, idx): +# return rt.wrap(ord(self.nth_char(idx.int_val()))) +# +# @extend(proto._nth_not_found, Buffer) +# def _nth_not_found(self, idx, not_found): +# return rt.wrap(ord(self.nth_char(idx.int_val()))) +# +# + +@extend_var("pixie.stdlib", "-count", Buffer) +def _count(self): + return rt.wrap(intmask(self.count())) + +@as_var("buffer") +def buffer(size): + return Buffer(size.int_val()) + +@as_var("buffer-capacity") +def buffer_capacity(buffer): + return rt.wrap(intmask(buffer.capacity())) + +@as_var("set-buffer-count!") +def set_buffer_size(self, size): + self.set_used_size(size.int_val()) + return self + +def make_itype(name, ctype, llt): + lltp = lltype.Ptr(lltype.Array(llt, hints={'nolength': True})) + class GenericCInt(CType): + def __init__(self): + CType.__init__(self, name) + + def ffi_get_value(self, ptr): + casted = rffi.cast(lltp, ptr) + return Integer(rffi.cast(rffi.LONG, casted[0])) + + def ffi_set_value(self, ptr, val): + casted = rffi.cast(lltp, ptr) + casted[0] = rffi.cast(llt, val.int_val()) + + def ffi_size(self): + return rffi.sizeof(llt) + + def ffi_type(self): + return ctype + + return GenericCInt() + +from rpython.rlib.rarithmetic import build_int +for x in [8, 16, 32, 64]: + for s in [True, False]: + nm = "C" + ("" if s else "U") + "Int" + str(x) + int_tp = lltype.build_number(None, build_int(nm, s, x)) + ctype = clibffi.cast_type_to_ffitype(int_tp) + make_itype(unicode("pixie.stdlib." + nm), ctype, int_tp) + + + + + + + +class Token(py_object): + """ Tokens are returned by ffi_set_value and are called when ffi is ready to clean up resources + """ + def finalize_token(self): + pass + + + +class CInt(CType): + def __init__(self): + CType.__init__(self, u"pixie.stdlib.CInt") + + def ffi_get_value(self, ptr): + casted = rffi.cast(rffi.INTP, ptr) + return Integer(rffi.cast(rffi.LONG, casted[0])) + + def ffi_set_value(self, ptr, val): + casted = rffi.cast(rffi.INTP, ptr) + casted[0] = rffi.cast(rffi.INT, val.int_val()) + + def ffi_size(self): + return rffi.sizeof(rffi.INT) + + def ffi_type(self): + return clibffi.cast_type_to_ffitype(rffi.INT) +CInt() + +class CDouble(CType): + def __init__(self): + CType.__init__(self, u"pixie.stdlib.CDouble") + + def ffi_get_value(self, ptr): + casted = rffi.cast(rffi.DOUBLEP, ptr) + return Float(casted[0]) + + def ffi_set_value(self, ptr, val): + casted = rffi.cast(rffi.DOUBLEP, ptr) + casted[0] = rffi.cast(rffi.DOUBLE, val.float_val()) + + def ffi_size(self): + return rffi.sizeof(rffi.DOUBLE) + + def ffi_type(self): + return clibffi.cast_type_to_ffitype(rffi.DOUBLE) +CDouble() + +class CCharP(CType): + def __init__(self): + CType.__init__(self, u"pixie.stdlib.CCharP") + + def ffi_get_value(self, ptr): + casted = rffi.cast(rffi.CCHARPP, ptr) + if casted[0] == lltype.nullptr(rffi.CCHARP.TO): + return nil + else: + return String(unicode(rffi.charp2str(casted[0]))) + + def ffi_set_value(self, ptr, val): + if isinstance(val, String): + pnt = rffi.cast(rffi.CCHARPP, ptr) + utf8 = unicode_to_utf8(val.get_name()) + raw = rffi.str2charp(utf8) + pnt[0] = raw + return CCharPToken(raw) + elif isinstance(val, Buffer): + vpnt = rffi.cast(rffi.VOIDPP, ptr) + vpnt[0] = val.buffer() + elif isinstance(val, VoidP): + vpnt = rffi.cast(rffi.VOIDPP, ptr) + vpnt[0] = val.raw_data() + elif val is nil: + vpnt = rffi.cast(rffi.VOIDPP, ptr) + vpnt[0] = rffi.cast(rffi.VOIDP, 0) + elif isinstance(val, CStruct): + vpnt = rffi.cast(rffi.VOIDPP, ptr) + vpnt[0] = rffi.cast(rffi.VOIDP, val.raw_data()) + else: + frm_name = val.to_repr() + to_name = self.to_repr() + affirm(False, u"Cannot encode " + frm_name + u" as " + to_name) + + + def ffi_size(self): + return rffi.sizeof(rffi.CCHARP) + + def ffi_type(self): + return clibffi.ffi_type_pointer +CCharP() + +class CCharPToken(Token): + def __init__(self, raw): + self._raw = raw + + def finalize_token(self): + rffi.free_charp(self._raw) + + + +class CVoid(CType): + def __init__(self): + CType.__init__(self, u"pixie.stdlib.CVoid") + + def ffi_get_value(self, ptr): + return nil + + def ffi_set_value(self, ptr, val): + runtime_error(u"Can't encode a Void") + + def ffi_size(self): + return rffi.sizeof(rffi.VOIDP) + + def ffi_type(self): + return clibffi.ffi_type_pointer + +cvoid = CVoid() + +class CVoidP(CType): + def __init__(self): + CType.__init__(self, u"pixie.stdlib.CVoidP") + + def ffi_get_value(self, ptr): + casted = rffi.cast(rffi.VOIDPP, ptr) + if casted[0] == lltype.nullptr(rffi.VOIDP.TO): + return nil + else: + return VoidP(casted[0]) + + def ffi_set_value(self, ptr, val): + pnt = rffi.cast(rffi.VOIDPP, ptr) + if isinstance(val, String): + pnt = rffi.cast(rffi.CCHARPP, ptr) + utf8 = unicode_to_utf8(val.get_name()) + raw = rffi.str2charp(utf8) + pnt[0] = raw + return CCharPToken(raw) + elif isinstance(val, Buffer): + pnt[0] = val.buffer() + elif isinstance(val, VoidP): + pnt[0] = val.raw_data() + elif val is nil: + pnt[0] = rffi.cast(rffi.VOIDP, 0) + elif isinstance(val, CStruct): + pnt[0] = rffi.cast(rffi.VOIDP, val.raw_data()) + else: + frm_name = val.to_repr() + to_name = self.to_repr() + affirm(False, u"Cannot encode " + frm_name + u" as " + to_name) + + + def ffi_size(self): + return rffi.sizeof(rffi.VOIDP) + + def ffi_type(self): + return clibffi.ffi_type_pointer +cvoidp = CVoidP() + +class VoidP(object.Object): + def type(self): + return cvoidp + + def __init__(self, raw_data): + self._raw_data = raw_data + + def raw_data(self): + return rffi.cast(rffi.VOIDP, self._raw_data) + + def free_data(self): + lltype.free(self._raw_data, flavor="raw") + +# @extend(proto._dispose_BANG_, cvoidp) +# def _dispose_voidp(self): +# self.free_data() + + + +@as_var(u"pixie.ffi", u"prep-string") +def prep_string(s): + """Takes a Pixie string and returns a VoidP to that string. The string should be freed via dispose!, otherwise + memory leaks could result.""" + affirm(isinstance(s, String), u"Can only prep strings with prep-string") + utf8 = unicode_to_utf8(s.get_name()) + raw = rffi.str2charp(utf8) + return VoidP(rffi.cast(rffi.VOIDP, raw)) + +@as_var(u"pixie.ffi", u"unpack") +def unpack(ptr, offset, tp): + """(unpack ptr offset tp) + Reads a value of type tp from offset of ptr.""" + affirm(isinstance(ptr, VoidP) or isinstance(ptr, Buffer) or isinstance(ptr, CStruct), u"Type is not unpackable") + affirm(isinstance(tp, CType), u"Packing type must be a CType") + ptr = rffi.ptradd(ptr.raw_data(), offset.int_val()) + return tp.ffi_get_value(ptr) + +@as_var(u"pixie.ffi", u"pack!") +def pack(ptr, offset, tp, val): + """(pack! ptr offset tp val) + Writes val at offset of ptr with the format tp""" + affirm(isinstance(ptr, VoidP) or isinstance(ptr, Buffer) or isinstance(ptr, CStruct), u"Type is not unpackable") + affirm(isinstance(tp, CType), u"Packing type must be a CType") + ptr = rffi.ptradd(ptr.raw_data(), offset.int_val()) + tp.ffi_set_value(ptr, val) + return nil + +@as_var(u"pixie.ffi", u"ptr-add") +def pack(ptr, offset): + affirm(isinstance(ptr, VoidP) or isinstance(ptr, Buffer) or isinstance(ptr, CStruct), u"Type is not unpackable") + ptr = rffi.ptradd(ptr.raw_data(), offset.int_val()) + return VoidP(ptr) + +class CStructType(object.Type): + base_type = object.Type(u"pixie.ffi.CStruct") + _immutable_fields_ = ["_desc", "_size"] + + def __init__(self, name, size, desc): + object.Type.__init__(self, name, CStructType.base_type) + self._desc = desc + self._size = size + #offsets is a dict of {nm, (type, offset)} + + def get_offset(self, nm): + (tp, offset) = self._desc.get(nm, (None, 0)) + + assert tp is not None + + return offset + + def get_type(self, nm): + (tp, offset) = self._desc.get(nm, (None, 0)) + + assert tp is not None + + return tp + + def get_size(self): + return self._size + + def cast_to(self, frm): + return CStruct(self, frm.raw_data()) + + @jit.elidable_promote() + def get_desc(self, nm): + return self._desc.get(nm, (None, 0)) + + def invoke(self, args): + return CStruct(self, rffi.cast(rffi.VOIDP, lltype.malloc(rffi.CCHARP.TO, self._size, flavor="raw"))) + + +registered_callbacks = {} + +class CCallback(object.Object): + _type = object.Type(u"pixie.ffi.CCallback") + + def __init__(self, cft, raw_closure, id, fn): + self._fn = fn + self._cft = cft + self._raw_closure = raw_closure + self._is_invoked = False + self._unique_id = id + + def type(self): + return CCallback._type + + def get_raw_closure(self): + return self._raw_closure + + def ll_invoke(self, llargs, llres): + cft = self._cft + assert isinstance(cft, CFunctionType) + + args = [None] * len(cft._arg_types) + for i, tp in enumerate(cft._arg_types): + args[i] = tp.ffi_get_value(llargs[i]) + + self._is_invoked = True + retval = self._fn.invoke(args) + if cft._ret_type is not cvoid: + cft._ret_type.ffi_set_value(llres, retval) + + + def cleanup(self): + del registered_callbacks[self._unique_id] + clibffi.closureHeap.free(self._raw_closure) + +# @extend(proto._dispose_BANG_, CCallback) +# def _dispose(self): +# self.cleanup() + + + +@as_var(u"pixie.ffi", u"-ffi-callback") +def ffi_callback(args, ret_type): + """(ffi-callback args ret-type) + Creates a ffi callback type. Args is a vector of CType args. Ret-type is the CType return + type of the callback. Returns a ffi callback type that can be used with ffi-prep-callback.""" + from pixie.vm2.array import Array + assert isinstance(args, Array) + args_w = args._list + + return CFunctionType(args_w, ret_type) + +@as_var(u"pixie.ffi", u"ffi-prep-callback") +def ffi_prep_callback(tp, f): + """(ffi-prep-callback callback-tp fn) + Prepares a Pixie function for use as a c callback. callback-tp is a ffi callback type, + fn is a pixie function (can be a closure, native fn or any object that implements -invoke. + Returns a function pointer that can be passed to c and invoked as a callback.""" + affirm(isinstance(tp, CFunctionType), u"First argument to ffi-prep-callback must be a CFunctionType") + raw_closure = rffi.cast(rffi.VOIDP, clibffi.closureHeap.alloc()) + + unique_id = rffi.cast(lltype.Signed, raw_closure) + + res = clibffi.c_ffi_prep_closure(rffi.cast(clibffi.FFI_CLOSUREP, raw_closure), tp.get_cd().cif, + invoke_callback, + rffi.cast(rffi.VOIDP, unique_id)) + + + if rffi.cast(lltype.Signed, res) != clibffi.FFI_OK: + registered_callbacks[unique_id] = None + runtime_error(u"libffi failed to build this callback") + + cb = CCallback(tp, raw_closure, unique_id, f) + registered_callbacks[unique_id] = cb + + return cb + +# Callback Code + +@jit.jit_callback("CFFI") +def invoke_callback(ffi_cif, ll_res, ll_args, ll_userdata): + cb = registered_callbacks[rffi.cast(rffi.INT_real, ll_userdata)] + cb.ll_invoke(ll_args, ll_res) + +class FunctionTypeNameGenerator(py_object): + def __init__(self): + self._idx = 0 + def next(self): + self._idx += 1 + return unicode("CFunctionType" + str(self._idx)) + +name_gen = FunctionTypeNameGenerator() + +class CFunctionType(object.Type): + base_type = object.Type(u"pixie.ffi.CType") + _immutable_fields_ = ["_arg_types", "_ret-type", "_cd"] + + def __init__(self, arg_types, ret_type): + object.Type.__init__(self, name_gen.next(), CStructType.base_type) + self._arg_types = arg_types + self._ret_type = ret_type + self._cd = CifDescrBuilder(self._arg_types, self._ret_type).rawallocate() + + def ffi_get_value(self, ptr): + runtime_error(u"Cannot get a callback value via FFI") + + def ffi_set_value(self, ptr, val): + affirm(isinstance(val, CCallback), u"Can only encode CCallbacks as function pointers") + + + casted = rffi.cast(rffi.VOIDPP, ptr) + casted[0] = val.get_raw_closure() + + return None + + def get_cd(self): + return self._cd + + def ffi_size(self): + return rffi.sizeof(rffi.VOIDP) + + def ffi_type(self): + return clibffi.ffi_type_pointer + +class CStruct(object.Object): + _immutable_fields_ = ["_type", "_buffer"] + def __init__(self, tp, buffer): + self._type = tp + self._buffer = buffer + + def type(self): + return self._type + + def raw_data(self): + return rffi.cast(rffi.VOIDP, self._buffer) + + def val_at(self, k, not_found): + (tp, offset) = self._type.get_desc(k) + + if tp is None: + return not_found + + offset = rffi.ptradd(self._buffer, offset) + return tp.ffi_get_value(rffi.cast(rffi.VOIDP, offset)) + + def set_val(self, k, v): + (tp, offset) = self._type.get_desc(k) + + if tp is None: + runtime_error(u"Invalid field name: " + k.to_repr()) + + offset = rffi.ptradd(self._buffer, offset) + tp.ffi_set_value(rffi.cast(rffi.VOIDP, offset), v) + + return nil + + def free_data(self): + lltype.free(self._buffer, flavor="raw") + +@wrap_fn +def _dispose_cstruct(self): + self.free_data() + + + + +@as_var("pixie.ffi", "c-struct") +def c_struct(name, size, spec): + """(c-struct name size spec) + Creates a CStruct named name, of size size, with the given spec. Spec is a vector + of vectors. Each row of the format [field-name type offset]""" + from pixie.vm2.array import Array + from pixie.vm2.code import intern_var + d = {} + assert isinstance(spec, Array) + spec_lst = spec._list + for x in range(len(spec_lst)): + row = spec_lst[x] + assert isinstance(row, Array) + row_lst = row._list + nm = row_lst[0] + tp = row_lst[1] + offset = row_lst[2] + + affirm(isinstance(nm, Keyword), u"c-struct field names must be keywords") + if not isinstance(tp, CType): + runtime_error(u"c-struct field types must be c types, got: " + tp.to_repr()) + + d[nm] = (tp, offset.int_val()) + + tp = CStructType(name.get_name(), size.int_val(), d) + + dispose_var = intern_var(u"pixie.stdlib", u"-dispose!") + dispose_var.deref().extend(tp, _dispose_cstruct) + return tp + +@as_var("pixie.ffi", "cast") +def c_cast(frm, to): + """(cast from to) + Converts a VoidP to a CStruct. From is either a VoidP or a CStruct, to is a CStruct type.""" + if not isinstance(to, CStructType): + runtime_error(u"Expected a CStruct type to cast to, got " + to.to_repr()) + + if not isinstance(frm, CStruct) and not isinstance(frm, VoidP): + runtime_error(u"From must be a CVoidP or a CStruct, got " + to.to_repr()) + + return to.cast_to(frm) + +@as_var("pixie.ffi", "struct-size") +def struct_size(tp): + """(struct-size tp) + Gives the size of the given CStruct type tp, in bytes.""" + if not isinstance(tp, CStructType): + runtime_error(u"Expected a CStruct type to get the size of, got " + tp.to_repr()) + + return rt.wrap(tp.get_size()) + +# @extend(proto._val_at, CStructType.base_type) +# def val_at(self, k, not_found): +# return self.val_at(k, not_found) + +@as_var("pixie.ffi", "set!") +def set_(self, k, val): + """(set! ptr k val) + Sets a field k of struct ptr to value val""" + return self.set_val(k, val) + + + +@as_var("pixie.ffi", "prep-ffi-call") +def prep_ffi_call__args(args): + fn = args[0] + affirm(isinstance(fn, CFunctionType), u"First arg must be a FFI function") + + + + + +import sys + +USE_C_LIBFFI_MSVC = getattr(clibffi, 'USE_C_LIBFFI_MSVC', False) + + + +class CifDescrBuilder(py_object): + rawmem = lltype.nullptr(rffi.CCHARP.TO) + + def __init__(self, fargs, fresult): + self.fargs = fargs + self.fresult = fresult + + def fb_alloc(self, size): + size = llmemory.raw_malloc_usage(size) + if not self.bufferp: + self.nb_bytes += size + return lltype.nullptr(rffi.CCHARP.TO) + else: + result = self.bufferp + self.bufferp = rffi.ptradd(result, size) + return result + + def fb_fill_type(self, ctype, is_result_type): + return ctype.ffi_type() + + + def fb_build(self): + # Build a CIF_DESCRIPTION. Actually this computes the size and + # allocates a larger amount of data. It starts with a + # CIF_DESCRIPTION and continues with data needed for the CIF: + # + # - the argument types, as an array of 'ffi_type *'. + # + # - optionally, the result's and the arguments' ffi type data + # (this is used only for 'struct' ffi types; in other cases the + # 'ffi_type *' just points to static data like 'ffi_type_sint32'). + # + nargs = len(self.fargs) + + # start with a cif_description (cif and exchange_* fields) + self.fb_alloc(llmemory.sizeof(CIF_DESCRIPTION, nargs)) + + # next comes an array of 'ffi_type*', one per argument + atypes = self.fb_alloc(rffi.sizeof(FFI_TYPE_P) * nargs) + self.atypes = rffi.cast(FFI_TYPE_PP, atypes) + + # next comes the result type data + self.rtype = self.fb_fill_type(self.fresult, True) + + # next comes each argument's type data + for i, farg in enumerate(self.fargs): + atype = self.fb_fill_type(farg, False) + if self.atypes: + self.atypes[i] = atype + + def align_arg(self, n): + return (n + 7) & ~7 + + def fb_build_exchange(self, cif_descr): + nargs = len(self.fargs) + + # first, enough room for an array of 'nargs' pointers + exchange_offset = rffi.sizeof(rffi.VOIDP) * nargs + exchange_offset = self.align_arg(exchange_offset) + cif_descr.exchange_result = exchange_offset + + # then enough room for the result, rounded up to sizeof(ffi_arg) + exchange_offset += max(rffi.getintfield(self.rtype, 'c_size'), + SIZE_OF_FFI_ARG) + + # loop over args + for i, farg in enumerate(self.fargs): + #if isinstance(farg, W_CTypePointer): + # exchange_offset += 1 # for the "must free" flag + exchange_offset = self.align_arg(exchange_offset) + cif_descr.exchange_args[i] = exchange_offset + exchange_offset += rffi.getintfield(self.atypes[i], 'c_size') + + # store the exchange data size + cif_descr.exchange_size = exchange_offset + + def fb_extra_fields(self, cif_descr): + cif_descr.abi = clibffi.FFI_DEFAULT_ABI # XXX + cif_descr.nargs = len(self.fargs) + cif_descr.rtype = self.rtype + cif_descr.atypes = self.atypes + + @jit.dont_look_inside + def rawallocate(self): + + # compute the total size needed in the CIF_DESCRIPTION buffer + self.nb_bytes = 0 + self.bufferp = lltype.nullptr(rffi.CCHARP.TO) + self.fb_build() + + # allocate the buffer + if we_are_translated(): + rawmem = lltype.malloc(rffi.CCHARP.TO, self.nb_bytes, + flavor='raw') + rawmem = rffi.cast(CIF_DESCRIPTION_P, rawmem) + else: + # gross overestimation of the length below, but too bad + rawmem = lltype.malloc(CIF_DESCRIPTION_P.TO, self.nb_bytes, + flavor='raw') + + # the buffer is automatically managed from the W_CTypeFunc instance + # ctypefunc._cd = rawmem + + # call again fb_build() to really build the libffi data structures + self.bufferp = rffi.cast(rffi.CCHARP, rawmem) + self.fb_build() + assert self.bufferp == rffi.ptradd(rffi.cast(rffi.CCHARP, rawmem), + self.nb_bytes) + + # fill in the 'exchange_*' fields + self.fb_build_exchange(rawmem) + + # fill in the extra fields + self.fb_extra_fields(rawmem) + + # call libffi's ffi_prep_cif() function + res = jit_libffi.jit_ffi_prep_cif(rawmem) + if res != clibffi.FFI_OK: + runtime_error(u"libffi failed to build function type") + + return rawmem + + def get_item(self, nm): + (tp, offset) = self._type.get_desc(nm) + ptr = rffi.ptradd(self._buffer, offset) + return tp.ffi_load_from(ptr) + +# unicode utils + +from rpython.rlib.runicode import str_decode_utf_8, unicode_encode_utf_8 + +def unicode_from_utf8(s): + """Converts a `str` value to a `unicode` value assuming it's encoded in UTF8.""" + res, _ = str_decode_utf_8(s, len(s), 'strict') + return res + +def unicode_to_utf8(s): + """Converts a `unicode` value to a UTF8 encoded `str` value.""" + return unicode_encode_utf_8(s, len(s), 'strict') diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index e6e3a954..a83a21eb 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -1,4 +1,5 @@ from pixie.vm2.object import Object, Type, Continuation, stack_cons, runtime_error, affirm +from pixie.vm2.code import ns_registry from pixie.vm2.primitives import nil, false from pixie.vm2.array import Array import pixie.vm2.code as code @@ -133,7 +134,14 @@ def __init__(self, name, args, body, closed_overs=[], meta=nil): if x in glocals: del glocals[x] - self._c_closed_overs = list(glocals.iterkeys()) + + closed_overs = [None] * len(glocals) + idx = 0 + for k in glocals: + closed_overs[idx] = glocals[k] + idx += 1 + + self._c_closed_overs = closed_overs def gather_locals(self): glocals = {} @@ -390,13 +398,25 @@ def get_ast(self): @expose("_c_var") class VDeref(AST): - _immutable_fields_ = ["_c_var"] - def __init__(self, var, meta=nil): + _immutable_fields_ = ["_c_in_ns", "_c_var_name"] + def __init__(self, in_ns, var_name, meta=nil): AST.__init__(self, meta) - self._c_var = var + self._c_in_ns = in_ns + self._c_var_ns = var_name.get_ns() + self._c_var_name = var_name.get_name() def interpret(self, val, locals, stack): - return self._c_var.deref(), stack + ns = ns_registry.find_or_make(self._c_in_ns) + if ns is None: + runtime_error(u"Namespace " + self._c_in_ns + u" is not found", + u"pixie.stdlib/UndefinedNamespace") + + var = ns.resolve_in_ns_ex(self._c_var_ns, self._c_var_name) + if var is not None: + return var.deref(), stack + else: + runtime_error(u"Var " + self._c_var_name + u" is undefined in " + self._c_in_ns, + u"pixie.stdlib/UndefinedVar") def gather_locals(self): return {} diff --git a/pixie/vm2/keyword.py b/pixie/vm2/keyword.py index 4fd2a397..d7f6fb83 100644 --- a/pixie/vm2/keyword.py +++ b/pixie/vm2/keyword.py @@ -2,8 +2,8 @@ from pixie.vm2.primitives import nil from pixie.vm2.string import String #import pixie.vm.stdlib as proto -from pixie.vm.code import extend, as_var -import pixie.vm.rt as rt +from pixie.vm2.code import extend, as_var +import pixie.vm2.rt as rt #import pixie.vm.util as util from rpython.rlib.rarithmetic import intmask, r_uint @@ -44,6 +44,14 @@ def to_repr(self): def store_hash(self, hash): self._hash = hash + def get_name(self): + self.init_names() + return rt.unwrap_string(self._w_name) + + def get_ns(self): + self.init_names() + return rt.unwrap_string(self._w_ns) + def get_hash(self): return self._hash diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index bf9d3605..4ac3795c 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -10,11 +10,17 @@ def type(self): affirm(False, u".type isn't overloaded") @jit.unroll_safe - def invoke(self, args): - #TODO: fix - runtime_error(u"bad invoke") - #import pixie.vm.stdlib as stdlib - #return stdlib.invoke_other(self, args) + def invoke_k(self, args, stack): + from pixie.vm2.code import intern_var + var = intern_var(u"pixie.stdlib", u"-invoke") + + new_args = [None] * (len(args) + 1) + + new_args[0] = self + for x in range(len(args)): + new_args[x + 1] = args[x] + + return var.deref().invoke_k(new_args, stack) def int_val(self): affirm(False, u"Expected Number, not " + self.type().name()) diff --git a/pixie/vm2/platform.py b/pixie/vm2/platform.py new file mode 100644 index 00000000..db285eb4 --- /dev/null +++ b/pixie/vm2/platform.py @@ -0,0 +1,23 @@ +from rpython.translator.platform import platform +from pixie.vm2.string import String +from pixie.vm2.code import as_var +from pixie.vm2.array import Array +from rpython.rlib.clibffi import get_libc_name +import os + + +as_var("pixie.platform", "os")(String(unicode(os.name))) +as_var("pixie.platform", "name")(String(unicode(platform.name))) +as_var("pixie.platform", "so-ext")(String(unicode(platform.so_ext))) +as_var("pixie.platform", "lib-c-name")(String(unicode(get_libc_name()))) + +c_flags = [] +for itm in platform.cflags: + c_flags.append(String(unicode(itm))) + +as_var("pixie.platform", "c-flags")(Array(c_flags)) + +link_flags = [] +for itm in platform.link_flags: + c_flags.append(String(unicode(itm))) +as_var("pixie.platform", "link-flags")(Array(link_flags)) diff --git a/pixie/vm2/pxic_reader.py b/pixie/vm2/pxic_reader.py index decb60a5..499e78c2 100644 --- a/pixie/vm2/pxic_reader.py +++ b/pixie/vm2/pxic_reader.py @@ -136,8 +136,9 @@ def read_object(os): elif tag == VAR: ns = read_raw_string(os) - name = read_raw_string(os) - return ast.VDeref(code.intern_var(ns, name)) + var_name = read_object(os) + meta = read_object(os) + return ast.VDeref(ns, var_name, meta) elif tag == VAR_CONST: diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index afb207d1..96bf1fa1 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -51,27 +51,11 @@ def wrapper(*args): import pixie.vm2.code as code import pixie.vm2.numbers as numbers import pixie.vm2.stdlib - #import pixie.vm.interpreter - #import pixie.vm.atom - #import pixie.vm.reduced - #import pixie.vm.util import pixie.vm2.array - #import pixie.vm.lazy_seq - #import pixie.vm.persistent_list - #import pixie.vm.persistent_hash_map - #import pixie.vm.persistent_hash_set import pixie.vm2.custom_types - #import pixie.vm.map_entry - #import pixie.vm.libs.platform - #import pixie.vm.libs.ffi - #import pixie.vm.libs.env - #import pixie.vm.symbol - #import pixie.vm.libs.path - #import pixie.vm.libs.string - #import pixie.vm.threads - #import pixie.vm.string_builder - #import pixie.vm.stacklet import pixie.vm2.jit_tables + import pixie.vm2.ffi + import pixie.vm2.platform @specialize.argtype(0) def wrap(x): @@ -139,7 +123,7 @@ def int_val(x): globals()["is_true"] = lambda x: False if x is false or x is nil or x is None else True - _type_registry.set_registry(code._ns_registry) + _type_registry.set_registry(code.ns_registry) numbers.init() code.init() diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 3e7f54a7..06502894 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -184,12 +184,6 @@ def _internal_store_hash(x, h): def _internal_int(x): return rt.wrap(x.int_val()) -@as_var("-internal-set-hash") -def _internal_sett_hash(x, hash_val): - x.set_hash(hash_val.int_val()) - return x - - @as_var("-blocking-println") def _blocking_println(x): print rt.unwrap_string(x) @@ -228,7 +222,7 @@ def type(x): def the_ns(ns_name): affirm(ns_name.get_ns() is None, u"the-ns takes a un-namespaced symbol") - return code._ns_registry.get(ns_name.get_name(), nil) + return code.ns_registry.get(ns_name.get_name(), nil) @as_var("load-ns") @@ -241,25 +235,74 @@ def load_ns(filename): affirm(filename.get_ns() is None, u"load-file takes a un-namespaced symbol") filename_str = filename.get_name().replace(u".", u"/") + u".pxi" - loaded_ns = code._ns_registry.get(filename.get_name(), None) + loaded_ns = code.ns_registry.get(filename.get_name(), None) if loaded_ns is not None: return loaded_ns else: affirm(isinstance(filename, string.String), u"Filename must be string") filename_str = filename.get_name - paths = rt.deref(rt.deref(rt.load_paths)) - f = None - for x in range(rt.count(paths)): - path_x = rt.nth(paths, rt.wrap(x)) - affirm(isinstance(path_x, string.String), u"Contents of load-paths must be strings") - full_path = path.join(str(rt.name(path_x)), str(filename_str)) - if path.isfile(full_path): - f = full_path - break - - if f is None: - affirm(False, u"File '" + rt.name(filename) + u"' does not exist in any directory found in load-paths") - else: - rt.load_file(rt.wrap(f)) - return nil \ No newline at end of file + # paths = rt.deref(rt.deref(rt.load_paths)) + # f = None + # for x in range(rt.count(paths)): + # path_x = rt.nth(paths, rt.wrap(x)) + # affirm(isinstance(path_x, string.String), u"Contents of load-paths must be strings") + # full_path = path.join(str(rt.name(path_x)), str(filename_str)) + # if path.isfile(full_path): + # f = full_path + # break + # + # if f is None: + # affirm(False, u"File '" + rt.name(filename) + u"' does not exist in any directory found in load-paths") + # else: + # rt.load_file(rt.wrap(f)) + return nil + + +### NS Helpers + +@as_var("-add-refer") +def refer_syms(in_ns_nm, other_ns_nm, as_nm): + from pixie.vm2.keyword import Keyword + from pixie.vm2.code import ns_registry + + in_ns = ns_registry.get(in_ns_nm.get_name(), None) + affirm(in_ns is not None, u"Can't locate namespace " + in_ns_nm.get_name()) + other_ns = ns_registry.get(other_ns_nm.get_name(), None) + affirm(other_ns is not None, u"Can't locate namespace " + in_ns_nm.get_name()) + + in_ns.add_refer(other_ns, as_nm.get_name()) + +@as_var("-refer-all") +def refer_all(in_ns_nm, other_ns_sym): + from pixie.vm2.keyword import Keyword + from pixie.vm2.code import ns_registry + + in_ns = ns_registry.get(in_ns_nm.get_name(), None) + affirm(in_ns is not None, u"Can't locate namespace " + in_ns_nm.get_name()) + + in_ns.get_refer(other_ns_sym.get_name()).refer_all() + + +@as_var("-refer-var") +def refer_all(in_ns_nm, other_ns_sym, old, new): + from pixie.vm2.keyword import Keyword + from pixie.vm2.code import ns_registry + + in_ns = ns_registry.get(in_ns_nm.get_name(), None) + affirm(in_ns is not None, u"Can't locate namespace " + in_ns_nm.get_name()) + + in_ns.get_refer(other_ns_sym.get_name()).add_var_alias(old.get_name(), new.get_name()) + + +@as_var("-in-ns") +def in_ns(ns_name): + ns = code.ns_registry.find_or_make(ns_name.get_name()) + ns.include_stdlib() + + return nil + +@as_var("-run-external-extends") +def run_external_extends(): + for var, tp, f in code.init_ctx: + var.deref().extend(tp, f) \ No newline at end of file diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index 8c90ecdb..67181c5c 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -20,6 +20,13 @@ def __init__(self, s): self._str = s + def get_name(self): + return self._str + + def get_ns(self): + return None + + @as_var("-str-len") def str_len(self): assert isinstance(self, String) @@ -119,6 +126,7 @@ def to_repr(self): #hexv = rt.name(rt.bit_str(rt.wrap(self.char_val()), rt.wrap(4))) #return rt.wrap(u"\\u" + u"0" * (4 - len(hexv)) + hexv) + class CharCache(object): def __init__(self): self._char_cache = {} From 4679153045d20ad680d550ea2d85cf0de3e1aa24 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Fri, 26 Jun 2015 16:08:48 -0600 Subject: [PATCH 26/46] can compile the compiler --- Makefile | 6 +- pixie/bootstrap.pxi | 164 ++++++++++++++++++++++++++++++++--- pixie/compiler.pxi | 179 ++++++++++++++------------------------- pixie/io-blocking.pxi | 28 +++--- pixie/stdlib.pxi | 24 +----- pixie/vm/stdlib.py | 2 +- pixie/vm2/array.py | 4 + pixie/vm2/code.py | 16 ++-- pixie/vm2/interpreter.py | 36 +++++++- pixie/vm2/object.py | 3 + pixie/vm2/stdlib.py | 18 +++- pixie/vm2/string.py | 10 +++ pixie/vm2/symbol.py | 12 +-- target2.py | 3 + 14 files changed, 321 insertions(+), 184 deletions(-) diff --git a/Makefile b/Makefile index d3c02278..9fb34f71 100644 --- a/Makefile +++ b/Makefile @@ -98,6 +98,6 @@ clean: clean_pxic rm -f ./*.pyc compile_rpython: - touch ./bootstrap.py - rm ./bootstrap.py - ./pixie-vm pixie/compiler.pxi + touch ./bootstrap.pxic + rm ./bootstrap.pxic + ../pixie-old/pixie-vm -l . pixie/compile-bootstrap.pxi diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 5d9231d8..2a47404f 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -48,7 +48,7 @@ (-dissoc [this k])) (defprotocol ILookup - (-get [this])) + (-val-at [this])) (defprotocol IMapEntry (-key [this]) @@ -293,7 +293,7 @@ :added "0.1"} ([coll] (-pop! coll))) -(def push! +(defn push! {:doc "Push an element on to a transient stack." :signatures [[] [coll] [coll item] [coll item & args]] :added "0.1"} @@ -326,6 +326,14 @@ [x] (satisfies? IMeta x)) +(defn meta + [x] + (-meta x)) + +(defn with-meta + [x m] + (-with-meta x m)) + (defn count ([coll] (-count coll))) @@ -345,6 +353,15 @@ (defn val [m] (-val m)) +(defn seq [x] + (-seq x)) + +(defn first [x] + (-first (seq x))) + +(defn next [x] + (-next (seq x))) + (defn apply [f & args] (let [last-itm (last args) but-last-cnt (dec (count args)) @@ -393,9 +410,44 @@ (deftype List [head tail cnt hash-val meta] + IObject + (-hash [this] + (if hash-val + hash-val + (let [val (reduce + pixie.stdlib.hashing/ordered-hashing-rf + this)] + (set-field! this :hash-val val) + val))) + + (-str [this sb] + (sb "(") + (let [not-first (atom false)] + (reduce + (fn [_ x] + (if @not-first + (sb " ") + (reset! not-first true)) + (-str x sb)) + nil + this)) + (sb ")")) + + IReduce + (-reduce [this f init] + (loop [acc init + s this] + (if (reduced? acc) + @acc + (if (nil? s) + acc + (recur (f acc (first s)) + (next s)))))) + + ISeq - (-first [this] first) - (-next [this] next) + (-first [this] head) + (-next [this] tail) ICounted (-count [this] cnt) @@ -417,7 +469,7 @@ (loop [acc nil idx (dec (count args)) cnt 0] - (if (pos? idx) + (if (>= idx 0) (recur (->List (nth args idx) acc cnt @@ -557,7 +609,7 @@ h1 seed] (if (< i (count u)) (let [k1 (bit-or (int (nth u (dec i))) - (int (nth u i))) + (bit-shift-left (int (nth u i)) 16)) k1 (mix-k1 k1) h1 (mix-h1 h1 k1)] (recur (+ 2 i) @@ -702,12 +754,13 @@ ;; Type Checks -(defn instance? [t x] +(defn instance? {:doc "Checks if x is an instance of t. When t is seqable, checks if x is an instance of any of the types contained therein." :signatures [[t x]]} + [t x] (if (-satisfies? ISeqable t) (let [ts (seq t)] (if (not ts) false @@ -716,12 +769,13 @@ (instance? (rest ts) x)))) (-instance? t x))) -(defn satisfies? [p x] +(defn satisfies? ^{:doc "Checks if x satisfies the protocol p. When p is seqable, checks if x satisfies all of the protocols contained therein." :signatures [[t x]]} + [p x] (if (-satisfies? ISeqable p) (let [ps (seq p)] (if (not ps) true @@ -741,9 +795,11 @@ (defn char? [v] (instance? Character v)) (defn string? [v] (instance? String v)) +(defn symbol? [v] (instance? Symbol v)) (defn keyword? [v] (instance? Keyword v)) (defn list? [v] (instance? [PersistentList Cons] v)) +(defn seq? [v] (satisfies? ISeq v)) (defn set? [v] (instance? PersistentHashSet v)) (defn map? [v] (satisfies? IMap v)) (defn fn? [v] (satisfies? IFn v)) @@ -1100,7 +1156,7 @@ ILookup - (-get [this val] + (-val-at [this val] (-nth-not-found self val nil)) @@ -1364,7 +1420,7 @@ key val added-leaf)] - (if (identical n val-or-node) + (if (identical? n val-or-node) this (->BitmapIndexedNode nil bitmap @@ -1571,7 +1627,7 @@ meta))))) ILookup - (-get [this key not-found] + (-val-at [this key not-found] (if (nil? key) (if has-nil? nil-val @@ -1602,7 +1658,9 @@ (defn create-node [shift key1 val1 key2hash key2 val2] (let [key1hash (bit-and (pixie.stdlib/hash key1) MASK-32)] (if (= key1hash key2hash) - (->HashCollisionNode nil key1hash [key1 val1 key2 val2]) + (do + (println "HASH " key1 val1 key2 val2 key1hash key2hash) + (->HashCollisionNode nil key1hash [key1 val1 key2 val2])) (let [added-leaf (atom false)] (-> BitmapIndexedNode-EMPTY (-assoc-inode shift key1hash key1 val1 added-leaf) @@ -1654,9 +1712,9 @@ (extend -invoke Keyword (fn ([this o] - (-get o this nil)) + (-val-at o this nil)) ([this o not-found] - (-get o this not-found)))) + (-val-at o this not-found)))) @@ -1787,6 +1845,67 @@ user => (refer 'pixie.string :exclude '(substring))" ;; End NS Functions +;; Delay + +(deftype Delay [f val] + (-deref [this] + (when f + (set-field! :val (f)) + (set-field! :f nil)) + val)) + +(defn -delay [f] + (->Delay f nil)) + +;; End Delay + +;; Dynamic Vars + +(defeffect EDynamicVar + (-dynamic-var-lookup [this]) + (-dynamic-var-set [this val])) + +(deftype DynamicVar [x] + IEffect + (-effect-val [this y] + (println "Effect Val" y) + (fn val-fn [s] y)) + + (-effect-return [this f] + (println "Effect Return " f) + (f x)) + + EDynamicVar + (-dynamic-var-lookup [this k] + (println "lookup") + (fn lookup-fn [s] + (println "lookup -> " s k) + ((k s) s))) + + (-dynamic-var-set [this s' k] + (println "call set " s' k) + (fn [s] + (println "Setting to | " s' s) + ((k nil) s'))) + + + IDeref + (-deref [this] + (-dynamic-var-lookup this)) + + IReset + (-reset! [this v] + (-dynamic-var-set this v))) + +(defn dynamic-var + ([] + (dynamic-var nil)) + ([v] + (->DynamicVar v))) + + +;; + ;; Multimethod stuff #_(comment @@ -1860,3 +1979,20 @@ user => (refer 'pixie.string :exclude '(substring))" ;; + + +;; Mutimethods + +(deftype MultiMethod [dispatch-fn default-val methods] + IFn + (-invoke [self & args] + (let [dispatch-val (apply dispatch-fn args) + method (if (contains? @methods dispatch-val) + (get @methods dispatch-val) + (get @methods default-val)) + _ (assert method (str "no method defined for " dispatch-val))] + (apply method args)))) + + + +;; diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 061abc27..a07c1666 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -1,8 +1,5 @@ (ns pixie.compiler - (:require [pixie.io :as io] - [pixie.string :as string] - [pixie.time :refer [time]] - [pixie.pxic-writer :as pxic-writer] + (:require [pixie.string :as string] [pixie.ast :refer :all])) @@ -73,6 +70,7 @@ :else (assert false "Unknown body element in deftype, expected symbol or seq")))) conj proto-bodies)] + (println type-nm all-fields field-syms ctor) `(do ~type-decl ~ctor ~@proto-bodies))) @@ -99,6 +97,9 @@ (str "Couldn't find the namespace " (quote ~ns) " after loading the file")) (apply refer ~ins (quote [~ns ~@args])))) + + + }) @@ -116,12 +117,16 @@ (number? x) :number (string? x) :string (char? x) :char - (keyword? x) :keyword))) + (keyword? x) :keyword + (map? x) :map))) (defmulti analyze-seq (fn [x] (let [f (first x)] (if (symbol? f) - f + (let [sname (symbol (name f))] + (if (get @(get-field analyze-seq :methods) sname) + sname + f)) :invoke)))) @@ -149,6 +154,30 @@ form *env*)) +(defmethod analyze-seq 'this-ns-name + [[_]] + (analyze-form (name @(:ns *env*)))) + +(defmethod analyze-seq 'with-handler + [[_ [h handler] & body]] + (analyze-form `(let [~h ~handler] + (~'pixie.stdlib/-effect-return + ~h + (~'pixie.stdlib/-with-handler + ~h + (fn [] + (~'pixie.stdlib/-effect-val + ~h + (do ~@body)))))))) + +(defmethod analyze-seq 'defeffect + [[_ nm & sigs]] + (analyze-form `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) + ~@(map (fn [[x]] + `(def ~x (~'pixie.stdlib/-effect-fn + (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))) + sigs)))) + (defmethod analyze-seq 'fn* [[_ & body :as form]] @@ -228,6 +257,10 @@ (assert (:tail? *env*) "Can only recur at tail position") (analyze-form `(~'__loop__fn__ ~@args))) +(defmethod analyze-seq 'var + [[_ nm]] + (->VarConst @(:ns *env*) nm nm env)) + (defmethod analyze-seq 'def [[_ nm val :as form]] (->Def @@ -238,7 +271,17 @@ (defmethod analyze-seq 'quote [[_ val]] - (->Const val *env*)) + (if (map? val) + (analyze-seq (with-meta + `(pixie.stdlib/hashmap ~@(reduce + (fn [acc [k v]] + (-> acc + (conj `(~'quote k)) + (conj `(~'quote v)))) + [] + val)) + (meta val))) + (->Const val *env*))) (defmethod analyze-seq 'in-ns [[_ nsp]] @@ -337,6 +380,18 @@ x *env*)) +(defmethod analyze-form :map + [x] + (analyze-seq (with-meta + `(pixie.stdlib/hashmap ~@(reduce + (fn [acc [k v]] + (-> acc + (conj k) + (conj v))) + [] + x)) + (meta x)))) + (defn maybe-var [x] (->Var @(:ns *env*) x x *env*)) @@ -364,113 +419,3 @@ (analyze-form form))))) - - -(defn walk [pre post selector node] - (let [walk-fn (partial walk pre post selector)] - (-> (reduce - (fn [node k] - (let [v (get node k) - result (if (or (vector? v) - (seq? v)) - (mapv walk-fn v) - (walk-fn v))] - (assoc node k result))) - (pre node) - (selector node)) - post))) - -(defn post-walk [f ast] - (walk identity f children-keys ast)) - - -(defn child-seq [ast] - (mapcat - (fn [k] - (let [child (get ast k)] - (if (or (vector? child) - (seq? child)) - child - [child]))) - (children-keys ast))) - -;; Collect Closed Overs - - -(defn collect-closed-overs [ast] - (let [closed-overs (set (or (get-closed-overs ast) - (mapcat get-closed-overs (child-seq ast)))) - closed-overs (if (instance? FnBody ast) - (reduce disj closed-overs (:args ast)) - closed-overs)] - (assoc-closed-overs ast closed-overs))) - - -;; End Collect Closed Overs - -(defn remove-env [ast] - (walk #(dissoc % :env) - identity - :children - ast)) - - -(defn run-passes [ast] - (walk identity - identity #_simplify-ast - children-keys - ast)) - -(defn read-and-compile [form env] - (let [ast (analyze form env)] - ast)) - -#_(defn compile-file [from to] - (println "Reading") - (let [form (time (read-string (str "(do " (pixie.io/slurp from) ")"))) - _ (println "Compiling") - ast (time (analyze form)) - _ (println "Passes") - ast (time (run-passes ast)) - _ (println "To String") - os (-> to - io/open-write - io/buffered-output-stream)] - (binding [pxic-writer/*cache* (pxic-writer/writer-cache os)] - (time (pxic-writer/write-object os ast))) - #_(print str) - (dispose! os) - (println "done"))) - -(defn compile-file [from os] - (let [forms (read-string (str "[" (io/slurp from) "]") from) - form-count (atom 0) - total-count (atom 0)] - (doseq [form forms] - (swap! form-count inc) - (swap! total-count inc) - (when (= @form-count 10) - (println from (int (* 100 (/ @total-count (count forms)))) "% in" @(:ns *env*)) - (reset! form-count 0)) - - (let [ast (read-and-compile form env)] - (pxic-writer/write-object os ast))))) - -(defn compile-files [files to] - (let [os (-> to - io/open-write - io/buffered-output-stream) - env (new-env) -] - (binding [*env* env] - (binding [pxic-writer/*cache* (pxic-writer/writer-cache os)] - (doseq [file files] - (compile-file file os)))) - (dispose! os))) - -(time (compile-files ["pixie/bootstrap.pxi" - "pixie/streams.pxi" - "pixie/io-blocking.pxi" - "pixie/reader.pxi" - "pixie/main.pxi"] - "./bootstrap.pxic")) diff --git a/pixie/io-blocking.pxi b/pixie/io-blocking.pxi index 1e376832..7f499ece 100644 --- a/pixie/io-blocking.pxi +++ b/pixie/io-blocking.pxi @@ -2,19 +2,7 @@ (:require [pixie.streams :as st :refer :all])) -(def DEFAULT-BUFFER-SIZE 1024) - -(defn stream-reducer [this f init] - (let [buf (buffer DEFAULT-BUFFER-SIZE) - rrf (preserving-reduced f)] - (loop [acc init] - (let [read-count (read this buf DEFAULT-BUFFER-SIZE)] - (if (> read-count 0) - (let [result (reduce rrf acc buf)] - (if (not (reduced? result)) - (recur result) - @result)) - acc))))) +(def DEFAULT-BUFFER-SIZE (* 32 1024)) @@ -30,6 +18,19 @@ (def popen (ffi-fn libc "popen" [CCharP CCharP] CVoidP)) (def pclose (ffi-fn libc "pclose" [CVoidP] CInt)) +(defn stream-reducer [this f init] + (let [buf (buffer DEFAULT-BUFFER-SIZE) + rrf (preserving-reduced f)] + (loop [acc init] + (let [read-count (read this buf DEFAULT-BUFFER-SIZE)] + (if (> read-count 0) + (let [result (reduce rrf acc buf)] + (if (not (reduced? result)) + (recur result) + @result)) + acc))))) + + (deftype FileStream [fp] IInputStream @@ -87,6 +88,7 @@ IByteOutputStream (write-byte [this val] (assert (integer? val) "Value must be a int") + (println val) (fputc val fp)) IOutputStream (write [this buffer] diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index 3a1d0ca9..f5426a04 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -2064,8 +2064,10 @@ The params can be destructuring bindings, see `(doc let)` for details."} [(merge meta (first args)) (next args)] [meta args]) dispatch-fn (first args) - options (apply hashmap (next args))] - `(def ~name (->MultiMethod ~(str name) ~dispatch-fn ~(get options :default :default) (atom {}))))) + options (apply hashmap (next args)) + result `(def ~name (->MultiMethod ~(str name) ~dispatch-fn ~(get options :default :default) (atom {})))] + (println result) + result)) (defmacro defmethod {:doc "Define a method of a multimethod. See `(doc defmulti)` for details." @@ -2419,24 +2421,6 @@ Calling this function on something that is not ISeqable returns a seq with that (let ~(vec (interleave bindings binding-syms)) ~@body))))) -(defmacro with-handler [[h handler] & body] - `(let [~h ~handler] - (~'pixie.stdlib/-effect-return - ~h - (~'pixie.stdlib/-with-handler - ~h - (fn [] - (~'pixie.stdlib/-effect-val - ~h - (do ~@body))))))) - -(defmacro defeffect - [nm & sigs] - `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) - ~@(map (fn [[x]] - `(def ~x (~'pixie.stdlib/-effect-fn - (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))) - sigs))) (extend -transient PersistentHashMap diff --git a/pixie/vm/stdlib.py b/pixie/vm/stdlib.py index 8b474a9d..cf1f41f8 100644 --- a/pixie/vm/stdlib.py +++ b/pixie/vm/stdlib.py @@ -723,7 +723,7 @@ def _var(ns, nm): @as_var("set-dynamic!") def set_dynamic(var): - affirm(isinstance(var, Var), u"set-dynamic! expects a var as an argument") + affirm(isinstance(var, Var), u"dynamic! expects a var as an argument") var.set_dynamic() return var diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py index 8d48285b..a67c065a 100644 --- a/pixie/vm2/array.py +++ b/pixie/vm2/array.py @@ -8,6 +8,7 @@ import rpython.rlib.jit as jit from rpython.rtyper.lltypesystem import lltype from rpython.rlib.rarithmetic import intmask +from rpython.rlib.objectmodel import we_are_translated from pixie.vm2.keyword import keyword import pixie.vm2.rt as rt UNROLL_IF_SMALLER_THAN = 8 @@ -22,6 +23,9 @@ def type(self): return Array._type def __init__(self, lst): + if we_are_translated(): + for x in lst: + assert x is not None self._list = lst @jit.unroll_safe diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index 0763ca22..f77ca2a2 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -388,7 +388,7 @@ def type(self): class DynamicVars(py_object): def __init__(self): - self._vars = rt.cons(rt.hashmap(), nil) + self._vars = [{}] def push_binding_frame(self): self._vars = rt.cons(rt.first(self._vars), self._vars) @@ -889,6 +889,8 @@ def assert_type(x, tp): def wrap_fn(fn, tp=object.Object): """Converts a native Python function into a pixie function.""" + import pixie.vm2.rt as rt + docstring = unicode(fn.__doc__) if fn.__doc__ else u"" def as_native_fn(f): return type("W" + fn.__name__, (NativeFn,), {"inner_invoke": f, "_doc": docstring})() @@ -898,7 +900,7 @@ def as_variadic_fn(f): code = fn.func_code if fn.__name__.endswith("__args"): - return as_variadic_fn(lambda self, args: fn(args)) + return as_variadic_fn(lambda self, args: rt.wrap(fn(args))) fn_name = unicode(getattr(fn, "__real_name__", fn.__name__)) @@ -910,7 +912,7 @@ def as_variadic_fn(f): def wrapped_fn(self, args): affirm(len(args) == 0, u"Expected 0 arguments to " + fn_name) try: - return fn() + return rt.wrap(fn()) except object.WrappedException as ex: #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) raise @@ -920,7 +922,7 @@ def wrapped_fn(self, args): def wrapped_fn(self, args): affirm(len(args) == 1, u"Expected 1 arguments to " + fn_name) try: - return fn(args[0]) + return rt.wrap(fn(args[0])) except object.WrappedException as ex: #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) raise @@ -930,7 +932,7 @@ def wrapped_fn(self, args): def wrapped_fn(self, args): affirm(len(args) == 2, u"Expected 2 arguments to " + fn_name) try: - return fn(args[0], args[1]) + return rt.wrap(fn(args[0], args[1])) except object.WrappedException as ex: #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) raise @@ -940,7 +942,7 @@ def wrapped_fn(self, args): affirm(len(args) == 3, u"Expected 3 arguments to " + fn_name) try: - return fn(args[0], args[1], args[2]) + return rt.wrap(fn(args[0], args[1], args[2])) except object.WrappedException as ex: #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) raise @@ -951,7 +953,7 @@ def wrapped_fn(self, args): affirm(len(args) == 4, u"Expected 4 arguments to " + fn_name) try: - return fn(args[0], args[1], args[2], args[3]) + return rt.wrap(fn(args[0], args[1], args[2], args[3])) except object.WrappedException as ex: #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) raise diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index a83a21eb..52c4fea8 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -106,6 +106,8 @@ def get_local(self, name): c = self while c._c_name is not name: c = c._c_next + if c is None: + runtime_error(name.to_repr() + u" is undefined") return c._c_value class Lookup(AST): @@ -162,6 +164,17 @@ def interpret(self, _, locals, stack): class InterpretedFn(code.BaseCode): _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name", "_c_arg_names"] + _type = Type(u"pixie.stdlib.InterpretedFn") + + def type(self): + return InterpretedFn._type + + def to_repr(self): + return u"" + + def to_str(self): + return u"" + def __init__(self, name, arg_names, locals_prefix, ast): assert isinstance(name, Keyword) code.BaseCode.__init__(self) @@ -183,7 +196,11 @@ def invoke_k_with(self, args, stack, self_fn): locals = Locals(self._c_name, self_fn, locals) if not len(args) == len(self._c_arg_names): - runtime_error(u"Wrong number args, expected " + unicode(str(len(args))) + u" got " + unicode(str(len(self._c_arg_names))), + runtime_error(u"Wrong number args to" + + self.to_repr() + + u", got " + + unicode(str(len(args))) + + u" expected " + unicode(str(len(self._c_arg_names))), u"pixie.stdlib.ArityException") for idx in range(len(self._c_arg_names)): @@ -290,6 +307,11 @@ def gather_locals(self): glocals = merge_dicts(glocals, x.gather_locals()) glocals = merge_dicts(glocals, self._c_body.gather_locals()) + + for x in self._c_names: + if x in glocals: + del glocals[x] + return glocals def interpret(self, _, locals, stack): @@ -489,7 +511,8 @@ def invoke_k(self, args, stack): fn = args[1] stack = stack_cons(stack, Handler(handler)) - return fn.invoke_k([], stack) + val, stack = fn.invoke_k([], stack) + return val, stack @@ -504,8 +527,16 @@ def handler(self): def get_ast(self): return None + def call_continuation(self, val, stack): + return val, stack + class DelimitedContinuation(code.NativeFn): _immutable_fields_ = ["_slice[*]"] + _type = Type(u"pixie.stdlib.DelmitedContinuation") + + def type(self): + return DelimitedContinuation._type + def __init__(self, slice): self._slice = slice @@ -559,6 +590,7 @@ def slice_stack(self, orig_stack, handler): break if isinstance(stack._cont, Handler) and stack._cont.handler() is handler: + size += 1 break size += 1 diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index 4ac3795c..4268730f 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -7,6 +7,8 @@ class Object(object): _attrs_ = () def type(self): + if not we_are_translated(): + print "FOR TYPE", self affirm(False, u".type isn't overloaded") @jit.unroll_safe @@ -146,6 +148,7 @@ class Continuation(object): should_enter_jit = False _immutable_ = True def call_continuation(self, val, stack): + assert False return None, stack def get_ast(self): diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 06502894..af53c735 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -305,4 +305,20 @@ def in_ns(ns_name): @as_var("-run-external-extends") def run_external_extends(): for var, tp, f in code.init_ctx: - var.deref().extend(tp, f) \ No newline at end of file + var.deref().extend(tp, f) + + +@as_var("set-dynamic!") +def set_dynamic(var): + affirm(isinstance(var, Var), u"set-dynamic! expects a var as an argument") + var.set_dynamic() + return var + + +@as_var("resolve-in") +def _var(ns, nm): + if not isinstance(ns, code.Namespace): + ns = code.ns_registry.find_or_make(ns.get_name()) + + var = ns.resolve_in_ns_ex(nm.get_ns(), nm.get_name()) + return var if var is not None else nil \ No newline at end of file diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index 67181c5c..82d1d445 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -220,3 +220,13 @@ def char(val): # def _hash(self): # assert isinstance(self, String) # return rt.wrap(intmask(util.hash_unencoded_chars(self._str))) + + +@as_var("pixie.string", "starts-with") +def startswith(a, b): + return rt.wrap(a.get_name().startswith(b.get_name())) + + +@as_var("pixie.string", "ends-with") +def endswith(a, b): + return rt.wrap(a.get_name().endswith(b.get_name())) diff --git a/pixie/vm2/symbol.py b/pixie/vm2/symbol.py index a22da332..3133a130 100644 --- a/pixie/vm2/symbol.py +++ b/pixie/vm2/symbol.py @@ -94,12 +94,12 @@ def symbol(s): # self._hash = util.hash_unencoded_chars(self._str) # return rt.wrap(intmask(self._hash)) # -# @as_var("symbol") -# def _symbol(s): -# if not isinstance(s, String): -# from pixie.vm.object import runtime_error -# runtime_error(u"Symbol name must be a string") -# return symbol(s._str) +@as_var("symbol") +def _symbol(s): + if not isinstance(s, String): + from pixie.vm.object import runtime_error + runtime_error(u"Symbol name must be a string") + return symbol(s.get_name()) # # # diff --git a/target2.py b/target2.py index ae946ab1..1e8cdf9a 100644 --- a/target2.py +++ b/target2.py @@ -11,6 +11,7 @@ from pixie.vm2.pxic_reader import read_file, read_object, Reader rt.init() +import sys def testit(max): rdr = Reader("./bootstrap.pxic") @@ -19,6 +20,8 @@ def testit(max): obj = read_object(rdr) except EOFError: break + print ".", + sys.stdout.flush() run_stack(None, i.InterpretK(obj, None)) return None From 0bf8d490d8b34f90ba78f733d72c231442953f62 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Thu, 2 Jul 2015 23:42:55 -0600 Subject: [PATCH 27/46] can compile the compiler, but the resulting compiler can't compile --- pixie/ast-output.pxi | 70 +++++++ pixie/ast.pxi | 176 ++++++++++++++++ pixie/bootstrap-macros.pxi | 156 +++++++++++++++ pixie/bootstrap.pxi | 311 +++++++++++++++++++++++++++-- pixie/compile-bootstrap.pxi | 48 +++++ pixie/compiler.pxi | 388 ++++++++++++++++-------------------- pixie/reader.pxi | 310 ++++++++++++++++++++++++++++ pixie/stdlib.pxi | 2 +- pixie/vm2/array.py | 3 + pixie/vm2/custom_types.py | 20 +- pixie/vm2/interpreter.py | 78 +++++++- pixie/vm2/keyword.py | 12 +- pixie/vm2/stdlib.py | 41 +++- 13 files changed, 1357 insertions(+), 258 deletions(-) create mode 100644 pixie/ast-output.pxi create mode 100644 pixie/ast.pxi create mode 100644 pixie/bootstrap-macros.pxi create mode 100644 pixie/compile-bootstrap.pxi create mode 100644 pixie/reader.pxi diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi new file mode 100644 index 00000000..dec03f06 --- /dev/null +++ b/pixie/ast-output.pxi @@ -0,0 +1,70 @@ +(ns pixie.ast-output + (:require [pixie.ast.internal :as iast] + [pixie.ast :as ast])) + +(defprotocol ToNativeAST + (-to-ast [this])) + +(defn meta-ast [ast] + nil) + +(defn to-ast [this] + (-to-ast this)) + +(extend-protocol ToNativeAST + + ast/If + (-to-ast [{:keys [test then else] :as ast}] + (ast/->If (to-ast test) + (to-ast then) + (to-ast else) + (meta-ast ast))) + + ast/Let + (-to-ast [{:keys [bindings body] :as ast}] + (ast/->Let (apply array (map #(keyword (name (:name %))) + bindings)) + (apply array (map #(to-ast :value %) + bindings)) + (to-ast body) + (meta-ast ast))) + + + ast/LetBinding + (-to-ast + [{:keys [name] :as ast}] + (iast/->Lookup name + (meta-ast ast))) + + + ast/Const + (-to-ast [{:keys [form] :as ast}] + (iast/->Const form (meta-ast ast))) + + ast/Invoke + (-to-ast [{:keys [args] :as ast}] + (let [args-array (make-array (inc (count args)))] + (aset args-array 0 (to-ast (:fn ast))) + (loop [idx 0] + (when (< idx (count args)) + (aset args-array + (inc idx) + (to-ast (nth args idx))) + (recur (inc idx)))) + (iast/->Invoke args-array + (meta-ast ast)))) + + + Object + (-to-ast [this] + (println this) + (throw [:pixie.stdlib/IllegalArgumentException + (str "Can't encode " this)]))) + +(defn simplify [ast] + (let [simplified (ast/simplify-ast ast)] + (if (identical? simplified ast) + ast + (recur simplified)))) + + diff --git a/pixie/ast.pxi b/pixie/ast.pxi new file mode 100644 index 00000000..dcba61b7 --- /dev/null +++ b/pixie/ast.pxi @@ -0,0 +1,176 @@ +(ns pixie.ast) + +(defprotocol IAst + (children-keys [this])) + +(extend-type Object + IAst + (children-keys [this] + (throw [:pixie.stdlib/IllegalArgumentException + (str "Can't get AST keys of " this)]))) + +(defrecord Meta [line column-number]) +(defrecord LineMeta [line file line-number]) + +(defrecord Do [statements ret form env] + IAst + (children-keys [this] + `[:statements :ret])) + +(defrecord If [test then else form env] + IAst + (children-keys [this] + `[:test :then :else])) + +(defrecord Fn [name arities form env] + IAst + (children-keys [this] + `[:arities])) + +(defrecord Binding [type name form env] + IAst + (children-keys [this] + `[])) + +(defrecord FnBody [name arity args closed-overs variadic? body form env] + IAst + (children-keys [this] + `[:body])) + +(defrecord Let [bindings body form env] + IAst + (children-keys [this] + `[:bindings :body])) + +(defrecord LetBinding [name value form env] + IAst + (children-keys [this] + `[:value])) + +(defrecord Def [name value form env] + IAst + (children-keys [this] + `[:value])) + + +(defrecord LocalMacro [name respace form env]) + +(defrecord Invoke [fn args tail-call? form env] + IAst + (children-keys [this] + `[:fn :args])) + +(defrecord Var [ns var-name form env] + IAst + (children-keys [this] + `[])) + +(defrecord VarConst [ns name form env] + IAst + (children-keys [this] + `[])) + +(defrecord Const [form env] + IAst + (children-keys [this] + `[])) + +(defrecord Vector [items form env] + IAst + (children-keys [this] + `[:items])) + +(defrecord Env [ns vars locals tail? meta bootstrap?]) + +;; Ctors + + +(defn make-invoke-ast [fn args form env] + (->Invoke fn args false form env)) + +(defn make-var-ast [ns name env] + (->Var ns name (symbol (pixie.stdlib/name name)) env)) + + +(defn make-var-const-ast [ns name env] + (->VarConst ns name (symbol (pixie.stdlib/name name)) env)) + +(defn make-invoke-var-ast [ns name args form env] + (make-invoke-ast + (make-var-ast ns name env) + args + form + env)) + +;; + +(defn convert-fn-body [name {:keys [variadic? args body form env] :as ast}] + (if variadic? + (make-invoke-var-ast + "pixie.stdlib" + (symbol "variadic-fn") + [(->Const (dec (count args)) env) + (convert-fn-body name (assoc ast :variadic? false))] + form + env) + ast)) + +(defprotocol ISimplfy + (simplify-ast [ast])) + +(extend-protocol ISimplfy + Do + (simplify-ast [{:keys [statements ret] :as ast}] + (if (= (count statements) 0) + ret + ast)) + + Let + (simplify-ast [{:keys [bindings body] :as ast}] + (if (= (count bindings) 0) + body + ast)) + + Fn + (simplify-ast [{:keys [name arities form env]}] + (if (= (count arities) 1) + (convert-fn-body name (first arities)) + (make-invoke-var-ast + "pixie.stdlib" + (symbol "multi-arity-fn") + (persistent! (reduce + (fn [acc {:keys [args variadic?] :as body}] + (-> acc + (conj! (->Const (if variadic? + -1 + (count args)) + env)) + (conj! (convert-fn-body name body)))) + (transient [(->Const (pixie.stdlib/name name) + env)]) + arities)) + form + env))) + + Vector + (simplify-ast [{:keys [items form env]}] + (make-invoke-var-ast + "pixie.stdlib" + (symbol "array") + items + form + env)) + + Def + (simplify-ast [{:keys [name env value form]}] + (make-invoke-var-ast + "pixie.stdlib" + (symbol "set-var-root!") + [(make-var-const-ast @(:ns env) name env) + value] + form + env)) + + Object + (simplify-ast [this] + this)) diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi new file mode 100644 index 00000000..7a5fd9ac --- /dev/null +++ b/pixie/bootstrap-macros.pxi @@ -0,0 +1,156 @@ +(ns pixie.bootstrap-macros) + +;; +;; 1) The compiler should translate pixie.bootstrap-macros/foo to pixie.stdlib/foo +;; 2) the compiler should allow these macros to override any other macros/locals but only during bootstrap compilation +;; + +(defmacro when [test & body] + `(if ~test (do ~@body))) + + +(defmacro deftype + [nm fields & body] + (let [ctor-name (symbol (str "->" (name nm))) + fields (transduce (map (comp keyword name)) conj fields) + field-syms (transduce (map (comp symbol name)) conj fields) + mk-body (fn [body] + (let [fn-name (first body) + _ (assert (symbol? fn-name) "protocol override must have a name") + args (second body) + _ (assert (or (vector? args) + (seq? args)) "protocol override must have arguments") + self-arg (first args) + _ (assert (symbol? self-arg) "protocol override must have at least one `self' argument") + + rest (next (next body)) + body (reduce + (fn [body f] + `[(local-macro [~(symbol (name f)) + (get-field ~self-arg ~(keyword (name f)))] + ~@body)]) + rest + fields)] + `(fn ~(symbol (str fn-name "_" nm)) ~args ~@body))) + bodies (reduce + (fn [res body] + (cond + (symbol? body) (cond + (= body 'Object) [body (second res) (third res)] + :else [body + (second res) + (conj (third res) body)]) + (seq? body) (let [proto (first res) tbs (second res) pbs (third res)] + (if (protocol? proto) + [proto tbs (conj pbs body)] + [proto (conj tbs body) pbs])))) + [nil [] []] + body) + proto-bodies (second bodies) + all-fields fields + type-nm (str #_@(:ns env) "." (name nm)) + type-decl `(def ~nm (create-type ~(keyword type-nm) + ~all-fields)) + inst (gensym) + ctor `(defn ~ctor-name ~field-syms + (new ~nm + ~@field-syms)) + proto-bodies (transduce + (map (fn [body] + (cond + (symbol? body) `(satisfy ~body ~nm) + (seq? body) `(extend ~(first body) + ~(symbol (str #_@(:ns env) "/" nm)) + ~(mk-body body)) + :else (assert false "Unknown body element in deftype, expected symbol or seq")))) + conj + proto-bodies)] + `(do ~type-decl + ~ctor + ~@proto-bodies))) + +(defmacro defprotocol + [nm & sigs] + `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) + ~@(map (fn [[x]] + `(def ~x (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm))) + sigs))) + + +(defmacro ns [nm & body] + (let [bmap (reduce (fn [m b] + (update-in m [(first b)] (fnil conj []) (rest b))) + {} + body) + requires + (do + (assert (>= 1 (count (:require bmap))) + "Only one :require block can be defined per namespace") + (println "NAme" (name nm)) + (mapv (fn [r] `(require ~(keyword (name nm)) ~@r)) (first (:require bmap))))] + `(do (in-ns ~(keyword (name nm))) + (println "in-ns " ~(keyword (name nm))) + ~@requires))) + +(defmacro require [ins ns & args] + (println "ns " ins ns (vec args)) + `(do (load-ns (quote ~ns)) + (assert (the-ns (quote ~ns)) + (str "Couldn't find the namespace " (quote ~ns) " after loading the file")) + + (apply refer ~ins (quote [~ns ~@args])))) + + +(defn -make-record-assoc-body [cname fields] + (let [k-sym (gensym "k") + v-sym (gensym "v") + this-sym (gensym "this") + result `(-assoc [~this-sym ~k-sym ~v-sym] + (case ~k-sym + ~@(mapcat + (fn [k] + [k `(~cname ~@(mapv (fn [x] + (if (= x k) + v-sym + `(get-field ~this-sym ~x))) + fields))]) + fields) + (throw [:pixie.stdlib/NotImplementedException + (str "Can't assoc to a unknown field: " ~k-sym)])))] + result)) + +(defmacro defrecord + {:doc "Define a record type. + +Similar to `deftype`, but supports construction from a map using `map->Type` +and implements IAssociative, ILookup and IObject." + :added "0.1"} + [nm field-syms & body] + (let [ctor-name (symbol (str "->" (name nm))) + map-ctor-name (symbol (str "map" (name ctor-name))) + fields (transduce (map (comp keyword name)) conj field-syms) + type-from-map `(defn ~map-ctor-name [m] + (apply ~ctor-name (map #(get m %) ~fields))) + default-bodies ['IAssociative + (-make-record-assoc-body ctor-name fields) + `(-contains-key [self k] + (contains? ~(set fields) k)) + `(-dissoc [self k] + (throw [:pixie.stdlib/NotImplementedException + "dissoc is not supported on defrecords"])) + 'ILookup + '(-val-at [self k not-found] + (get-field self k not-found)) + 'IObject + `(-str [self# sb#] + (sb# (str "<" ~(name nm) " >" ))) + `(-eq [self other] + (and (instance? ~nm other) + ~@(map (fn [field] + `(= (. self ~field) (. other ~field))) + fields))) + `(-hash [self] + (hash [~@field-syms]))] + deftype-decl `(deftype ~nm ~fields ~@default-bodies ~@body)] + `(do ~type-from-map + ~deftype-decl))) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 2a47404f..63d04e79 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -97,7 +97,37 @@ (defprotocol IEffect (-effect-val [this v]) - (-effect-return [this v])) + (-effect-finally [this v])) + +(defeffect EException + (-throw [this kw data ks])) + +(deftype ExceptionHandler [catches finally-fn] + IEffect + (-effect-val [this v] + v) + + (-effect-finally [this v] + (when finally-fn + (finally-fn)) + v) + + EException + (-throw [this kw data ks k] + (let [c (get catches kw)] + (if c + (c data) + (-throw this kw data (conj ks k)))))) + +(defn throw [kw val] + (-throw nil + kw + val + [])) + +(defn -try [body catches finally] + (with-handler [ex (->ExceptionHandler catches finally)] + (body))) (-run-external-extends) @@ -308,6 +338,18 @@ ([coll idx] (-nth coll idx)) ([coll idx not-found] (-nth-not-found coll idx not-found))) +(defn get + {:doc "Get an element from a collection implementing ILookup, return nil or the default value if not found." + :added "0.1"} + ([mp k] + (get mp k nil)) + ([mp k not-found] + (-val-at mp k not-found))) + +(defn contains? + [mp k] + (-contains-key mp k)) + (defn name [x] (-name x)) @@ -362,18 +404,31 @@ (defn next [x] (-next (seq x))) +(defn nthnext + {:doc "Returns the result of calling next n times on the collection." + :examples [["(nthnext [1 2 3 4 5] 2)" nil (3 4 5)] + ["(nthnext [1 2 3 4 5] 7)" nil nil]] + :added "0.1"} + [coll n] + (loop [n n + xs (seq coll)] + (if (and xs (pos? n)) + (recur (dec n) (next xs)) + xs))) + + (defn apply [f & args] (let [last-itm (last args) but-last-cnt (dec (count args)) arg-array (make-array (+ but-last-cnt (count last-itm))) - _ (array-copy args 0 arg-array 0 but-last-cnt) idx (reduce (fn [idx itm] (aset arg-array idx itm) (inc idx)) but-last-cnt last-itm)] + (array-copy args 0 arg-array 0 but-last-cnt) (-apply f arg-array))) (defn last [coll] @@ -392,6 +447,15 @@ (next coll)) (seq res)))) +(defn seq-reduce [s f acc] + (if (reduced? acc) + @acc + (if (nil? s) + acc + (seq-reduce (next s) + f + (f acc (first s)))))) + ;; Cons and List (deftype Cons [first next meta] @@ -433,16 +497,34 @@ this)) (sb ")")) + + IIndexed + + (-nth [self idx] + (loop [i idx + s (seq self)] + (if (or (= i 0) + (nil? s)) + (if (nil? s) + (first s) + (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"])) + (recur (dec i) + (next s))))1) + + (-nth-not-found [self idx not-found] + (loop [i idx + s (seq self)] + (if (or (= i 0) + (nil? s)) + (if (nil? s) + (first s) + not-found) + (recur (dec i)0 + (next s))))) + IReduce (-reduce [this f init] - (loop [acc init - s this] - (if (reduced? acc) - @acc - (if (nil? s) - acc - (recur (f acc (first s)) - (next s)))))) + (seq-reduce this f init)) ISeq @@ -468,7 +550,7 @@ (defn list [& args] (loop [acc nil idx (dec (count args)) - cnt 0] + cnt 1] (if (>= idx 0) (recur (->List (nth args idx) acc @@ -479,6 +561,78 @@ (inc cnt)) acc))) +;; LazySeq start +(in-ns :pixie.stdlib.lazy-seq) + + +(deftype LazySeq [f s hash-val meta-data] + ISeqable + (-seq [this] + (sval this) + (when (.-s this) + (loop [ls (.-s this)] + (if (instance? LazySeq ls) + (recur (sval ls)) + (do (set-field! this :s ls) + (seq (.-s this))))))) + + ISeq + (-first [this] + (seq this) + (first (.-s this))) + + (-next [this] + (seq this) + (next (.-s this))) + + IReduce + (-reduce [this f init] + (seq-reduce this f init)) + + IMessageObject + (-get-field [this field] + (get-field this field))) + +(defn sval [this] + (if (.-f this) + (do (set-field! this :s ((.-f this))) + (set-field! this :f nil) + (.-s this)) + (.-s this))) + + +(in-ns :pixie.stdlib) + +(defn lazy-seq* [f] + (pixie.stdlib.lazy-seq/->LazySeq f nil nil nil)) + +(defeffect EGenerator + (-yield [this val])) + +(deftype Generator [] + IEffect + (-effect-val [this val] + nil) + (-effect-finally [this val] + val) + + EGenerator + (-yield [this val k] + (cons val (lazy-seq + (with-handler [_ this] + (k nil)))))) + +(defn yield [g i] + (-yield g i) + g) + +(defn sequence [coll] + (with-handler [gen (->Generator)] + (reduce yield gen coll))) + + + +;; LazySeq end ;; String Builder @@ -692,7 +846,7 @@ (let [s (seq coll)] (if s (cons (f (first s)) - (map f (rest s))) + (map f (next s))) nil))))) ([f & colls] (let [step (fn step [cs] @@ -700,10 +854,14 @@ (fn [] (let [ss (map seq cs)] (if (every? identity ss) - (cons (map first ss) (step (map rest ss))) + (cons (map first ss) (step (map next ss))) nil)))))] (map (fn [args] (apply f args)) (step colls))))) +(defn mapv + ([f col] + (transduce (map f) conj col))) + (defn interpose ^{:doc "Returns a transducer that inserts `val` in between elements of a collection." @@ -741,6 +899,12 @@ ([result input] (reduce rrf result input))))) +(defn concat + {:doc "Concatenates its arguments." + :signatures [[& args]] + :added "0.1"} + [& args] (transduce cat conj args)) + (defn mapcat {:doc "Maps f over the elements of coll and concatenates the result" :added "0.1"} @@ -800,7 +964,7 @@ (defn list? [v] (instance? [PersistentList Cons] v)) (defn seq? [v] (satisfies? ISeq v)) -(defn set? [v] (instance? PersistentHashSet v)) +(defn set? [v] (instance? pixie.stdlib.persistent-hash-set/PersistentHashSet v)) (defn map? [v] (satisfies? IMap v)) (defn fn? [v] (satisfies? IFn v)) @@ -1102,7 +1266,11 @@ (-str x sb)) nil this)) - (sb "]")) + (sb "]")) + + ISeqable + (-seq [this] + (sequence this)) IMessageObject @@ -1561,6 +1729,10 @@ acc)))) (deftype PersistentHashMap [cnt root has-nil? nil-val hash-val meta] + IFn + (-invoke [this k] + (-val-at this k nil)) + IObject (-hash [this] (if hash-val @@ -1626,6 +1798,11 @@ nil meta))))) + (-contains-key [this k] + (if (identical? (-val-at this k NOT-FOUND) NOT-FOUND) + false + true)) + ILookup (-val-at [this key not-found] (if (nil? key) @@ -1639,6 +1816,8 @@ key not-found)))) + + IReduce (-reduce [this f init] (let [acc (if has-nil? @@ -1653,6 +1832,9 @@ acc)) acc))))) +(deftype NOT-FOUND-TP []) +(def NOT-FOUND (->NOT-FOUND-TP)) + (def EMPTY (->PersistentHashMap (size-t 0) nil false nil nil nil)) (defn create-node [shift key1 val1 key2hash key2 val2] @@ -1689,6 +1871,80 @@ acc))) ;; End Persistent Hash Map + +;; Start Persistent Hash Set + +(in-ns :pixie.stdlib.persistent-hash-set) + +(deftype PersistentHashSet [m hash-val meta] + IObject + (-hash [this] + (when-not hash-val + (set! this :hash-val (reduce + unordered-hashing-rf + this))) + hash-val) + + (-str [this sb] + (sb "#{") + (let [not-first (atom false)] + (reduce + (fn [_ x] + (if @not-first + (sb " ") + (reset! not-first true)) + (-str x sb)) + nil + this)) + (sb "}")) + + ICounted + (-count [this] + (-count m)) + + IPersistentCollection + (-conj [this x] + (->PersistentHashSet (-assoc m x x) nil meta)) + (-disj [this x] + (->PersistentHashSet (-dissoc m x) nil meta)) + + IMeta + (-meta [this] + meta) + + (-with-meta [this x] + (->PersistentHashSet m hash-val x)) + + IAssociative + (-contains-key [this x] + (-contains-key m x)) + + ILookup + (-val-at [this k not-found] + (-val-at m k not-found)) + + IReduce + (-reduce [this f init] + (reduce + (fn [acc kv] + (f acc (key kv))) + init + m))) + +(def EMPTY (->PersistentHashSet + pixie.stdlib.persistent-hash-map/EMPTY + nil + nil)) + +;; End Persistent Hash Set + +(in-ns :pixie.stdlib) + +(defn set [coll] + (into pixie.stdlib.persistent-hash-set/EMPTY + coll)) + + ;; Extend Core Types (extend -invoke Code -invoke) @@ -1782,7 +2038,21 @@ IReduce (-reduce [this f init] - init)) + init) + + ICounted + (-count [this] + 0) + + ISeqable + (-seq [this] + nil) + + ISeq + (-first [this] + nil) + (-next [this] + nil)) (extend -with-meta Nil (fn [self _] nil)) @@ -1820,6 +2090,8 @@ user => (refer 'pixie.string :exclude '(substring))" :added "0.1"} [from-ns ns-sym & filters] (println ns-sym) + (assert ns-sym "Must provide a ns-sym") + (assert from-ns "Must provide a from-ns") (let [ns (or (the-ns ns-sym) (throw [:pixie.stdlib/NamespaceNotFoundException (str "No such namespace: " ns-sym)])) filters (apply hashmap filters) @@ -1871,7 +2143,7 @@ user => (refer 'pixie.string :exclude '(substring))" (println "Effect Val" y) (fn val-fn [s] y)) - (-effect-return [this f] + (-effect-finally [this f] (println "Effect Return " f) (f x)) @@ -1987,9 +2259,8 @@ user => (refer 'pixie.string :exclude '(substring))" IFn (-invoke [self & args] (let [dispatch-val (apply dispatch-fn args) - method (if (contains? @methods dispatch-val) - (get @methods dispatch-val) - (get @methods default-val)) + method (or (get @methods dispatch-val) + (get @methods default-val)) _ (assert method (str "no method defined for " dispatch-val))] (apply method args)))) diff --git a/pixie/compile-bootstrap.pxi b/pixie/compile-bootstrap.pxi new file mode 100644 index 00000000..6c67eda2 --- /dev/null +++ b/pixie/compile-bootstrap.pxi @@ -0,0 +1,48 @@ +(ns pixie.compile-bootstrap + (:require [pixie.compiler :refer :all] + [pixie.io :as io] + [pixie.pxic-writer :as pxic-writer] + [pixie.bootstrap-macros])) + + + +(defn read-and-compile [form env] + (let [ast (analyze form env)] + ast)) + +(defn compile-file [env from os] + (let [forms (read-string (str "[" (io/slurp from) "]") from) + form-count (atom 0) + total-count (atom 0)] + (doseq [form forms] + (swap! form-count inc) + (swap! total-count inc) + (when (= @form-count 10) + (println from (int (* 100 (/ @total-count (count forms)))) "% in" @(:ns env)) + (reset! form-count 0)) + + (let [ast (read-and-compile form env)] + (pxic-writer/write-object os ast))))) + +(defn compile-files [files to] + (let [os (-> to + io/open-write + io/buffered-output-stream) + env (new-env true)] + + (binding [pxic-writer/*cache* (pxic-writer/writer-cache os)] + (doseq [file files] + (compile-file env file os))) + (dispose! os))) + +(compile-files ["pixie/bootstrap.pxi" + #_"pixie/bootstrap-macros.pxi" + "pixie/streams.pxi" + "pixie/io-blocking.pxi" + "pixie/reader.pxi" + "pixie/ast.pxi" + "pixie/ast-output.pxi" + "pixie/compiler.pxi" + "pixie/main.pxi"] + "./bootstrap.pxic") + diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index a07c1666..425dab9a 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -3,110 +3,7 @@ [pixie.ast :refer :all])) -(def macro-overrides - { - (resolve 'defprotocol) - (fn - [nm & sigs] - `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) - ~@(map (fn [[x]] - `(def ~x (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm))) - sigs))) - - (resolve 'deftype) - (fn deftype - [nm fields & body] - (let [ctor-name (symbol (str "->" (name nm))) - fields (transduce (map (comp keyword name)) conj fields) - field-syms (transduce (map (comp symbol name)) conj fields) - mk-body (fn [body] - (let [fn-name (first body) - _ (assert (symbol? fn-name) "protocol override must have a name") - args (second body) - _ (assert (or (vector? args) - (seq? args)) "protocol override must have arguments") - self-arg (first args) - _ (assert (symbol? self-arg) "protocol override must have at least one `self' argument") - - rest (next (next body)) - body (reduce - (fn [body f] - `[(local-macro [~(symbol (name f)) - (get-field ~self-arg ~(keyword (name f)))] - ~@body)]) - rest - fields)] - `(fn ~(symbol (str fn-name "_" nm)) ~args ~@body))) - bodies (reduce - (fn [res body] - (cond - (symbol? body) (cond - (= body 'Object) [body (second res) (third res)] - :else [body - (second res) - (conj (third res) body)]) - (seq? body) (let [proto (first res) tbs (second res) pbs (third res)] - (if (protocol? proto) - [proto tbs (conj pbs body)] - [proto (conj tbs body) pbs])))) - [nil [] []] - body) - proto-bodies (second bodies) - all-fields fields - type-nm (str @(:ns *env*) "." (name nm)) - type-decl `(def ~nm (create-type ~(keyword type-nm) - ~all-fields)) - inst (gensym) - ctor `(defn ~ctor-name ~field-syms - (new ~nm - ~@field-syms)) - proto-bodies (transduce - (map (fn [body] - (cond - (symbol? body) `(satisfy ~body ~nm) - (seq? body) `(extend ~(first body) - ~(symbol (str @(:ns *env*) "/" nm)) - ~(mk-body body)) - :else (assert false "Unknown body element in deftype, expected symbol or seq")))) - conj - proto-bodies)] - (println type-nm all-fields field-syms ctor) - `(do ~type-decl - ~ctor - ~@proto-bodies))) - - (resolve 'ns) - (fn ns [nm & body] - (let [bmap (reduce (fn [m b] - (update-in m [(first b)] (fnil conj []) (rest b))) - {} - body) - requires - (do - (assert (>= 1 (count (:require bmap))) - "Only one :require block can be defined per namespace") - (mapv (fn [r] `(require ~(keyword (name nm)) ~@r)) (first (:require bmap))))] - `(do (in-ns ~(keyword (name nm))) - (println "in-ns " ~(keyword (name nm))) - ~@requires))) - - (resolve 'require) - (fn [ins ns & args] - `(do (load-ns (quote ~ns)) - (assert (the-ns (quote ~ns)) - (str "Couldn't find the namespace " (quote ~ns) " after loading the file")) - - (apply refer ~ins (quote [~ns ~@args])))) - - - - }) - - -(def *env* nil) -(set-dynamic! (var *env*)) - -(defmulti analyze-form (fn [x] +(defmulti analyze-form (fn [_ x] (cond (identical? x true) :bool (identical? x false) :bool @@ -118,9 +15,11 @@ (string? x) :string (char? x) :char (keyword? x) :keyword - (map? x) :map))) + (map? x) :map + (set? x) :set + :else (type x)))) -(defmulti analyze-seq (fn [x] +(defmulti analyze-seq (fn [_ x] (let [f (first x)] (if (symbol? f) (let [sname (symbol (name f))] @@ -133,35 +32,35 @@ ;; Special Forms (defmethod analyze-seq 'do - [x] - (let [statement-asts (binding [*env* (assoc *env* :tail? false)] - (mapv analyze-form (butlast (next x))))] + [env x] + (let [statement-asts (mapv (partial analyze-form (assoc env :tail? false)) + (butlast (next x)))] (->Do statement-asts - (analyze-form (last x)) + (analyze-form env (last x)) x - *env*))) + env))) (defmethod analyze-seq 'comment - [x] - (->Const x *env*)) + [env x] + (->Const x env)) (defmethod analyze-seq 'if - [[_ test then else :as form]] - (->If (binding [*env* (assoc *env* :tail? false)] - (analyze-form test)) - (analyze-form then) - (analyze-form else) + [env [_ test then else :as form]] + (->If (analyze-form (assoc env :tail? false) test) + (analyze-form env then) + (analyze-form env else) form - *env*)) + env)) (defmethod analyze-seq 'this-ns-name - [[_]] - (analyze-form (name @(:ns *env*)))) + [env [_]] + (analyze-form env (name @(:ns env)))) (defmethod analyze-seq 'with-handler - [[_ [h handler] & body]] - (analyze-form `(let [~h ~handler] - (~'pixie.stdlib/-effect-return + [env [_ [h handler] & body]] + (analyze-form env + `(let [~h ~handler] + (~'pixie.stdlib/-effect-finally ~h (~'pixie.stdlib/-with-handler ~h @@ -171,16 +70,17 @@ (do ~@body)))))))) (defmethod analyze-seq 'defeffect - [[_ nm & sigs]] - (analyze-form `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) - ~@(map (fn [[x]] - `(def ~x (~'pixie.stdlib/-effect-fn - (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))) - sigs)))) + [env [_ nm & sigs]] + (analyze-form env + `(do (def ~nm (~'pixie.stdlib/protocol ~(str nm))) + ~@(map (fn [[x]] + `(def ~x (~'pixie.stdlib/-effect-fn + (~'pixie.stdlib/polymorphic-fn ~(str x) ~nm)))) + sigs)))) (defmethod analyze-seq 'fn* - [[_ & body :as form]] + [env [_ & body :as form]] (let [[name body] (if (symbol? (first body)) [(first body) (next body)] @@ -190,23 +90,53 @@ [body] body) analyzed-bodies (reduce - (partial analyze-fn-body name) + (partial analyze-fn-body env name) {} arities)] (->Fn name (vals analyzed-bodies) form - *env*))) + env))) + +(defmethod analyze-seq 'try + [env [_ & body :as form]] + (let [analyzed (reduce + (fn [acc f] + (cond + (and (seq? f) + (= (first f) 'catch)) + (let [[_ k ex-nm & body] f] + (assert (keyword? k) "First argument to catch must be a keyword") + (assoc-in acc [:catches k] `(fn [~ex-nm] + ~body))) + (and (seq? f) + (= (first f) 'finally)) + (let [[_ & body] f] + (assert (nil? (:finally acc)) "Can only have one finally block in a try") + (assoc acc :finally `(fn [] + ~@body))) + + :else (update-in acc [:bodies] conj f))) + {} + body)] + (analyze-form env `(~'pixie.stdlib/-try + (fn [] + ~@(or (:bodies analyzed) + [])) + ~(or (:catches analyzed) + {}) + ~(or (:finally analyzed) + `(fn [] nil)))))) (defn add-local [env type bind-name] - (assoc-in env [:locals bind-name] (->Binding type bind-name bind-name *env*))) + (assoc-in env [:locals bind-name] (->Binding type bind-name bind-name env))) -(defn analyze-fn-body [fn-name acc [args & body :as form]] +(defn analyze-fn-body [env fn-name acc [args & body :as form]] (let [[args variadic?] (let [not& (vec (filter (complement (partial = '&)) args))] [not& (= '& (last (butlast args)))]) arity (count args) arity-idx (if variadic? -1 arity) - new-env (add-local *env* :fn-self fn-name) + new-env (add-local env :fn-self fn-name) new-env (reduce (fn [acc arg-name] (add-local acc :arg arg-name)) @@ -218,59 +148,60 @@ args nil variadic? - (binding [*env* (assoc new-env :tail? true)] - (analyze-form (cons 'do body))) + (analyze-form + (assoc new-env :tail? true) + (cons 'do body)) form - *env*)))) + env)))) (defmethod analyze-seq 'let* - [[_ bindings & body :as form]] + [env [_ bindings & body :as form]] (assert (even? (count bindings)) "Let requires an even number of bindings") (let [parted (partition 2 bindings) [new-env bindings] (reduce (fn [[new-env bindings] [name binding-form]] - (let [binding-ast (binding [*env* new-env] - (->LetBinding name - (binding [*env* (assoc *env* :tail? false)] - (analyze-form binding-form)) - binding-form - *env*))] + (let [binding-ast (->LetBinding name + (analyze-form + (assoc new-env :tail? false) + binding-form) + binding-form + env)] [(assoc-in new-env [:locals name] binding-ast) (conj bindings binding-ast)])) - [*env* []] + [env []] parted)] (->Let bindings - (binding [*env* new-env] - (analyze-form `(do ~@body))) + (analyze-form new-env `(do ~@body)) form - *env*))) + env))) (defmethod analyze-seq 'loop* - [[_ bindings & body]] + [env [_ bindings & body]] (let [parted (partition 2 bindings)] - (analyze-form `((fn ~'__loop__fn__ ~(mapv first parted) + (analyze-form env + `((fn ~'__loop__fn__ ~(mapv first parted) ~@body) ~@(mapv second parted))))) (defmethod analyze-seq 'recur - [[_ & args]] - (assert (:tail? *env*) "Can only recur at tail position") - (analyze-form `(~'__loop__fn__ ~@args))) + [env [_ & args]] + (assert (:tail? env) "Can only recur at tail position") + (analyze-form env `(~'__loop__fn__ ~@args))) (defmethod analyze-seq 'var - [[_ nm]] - (->VarConst @(:ns *env*) nm nm env)) + [env [_ nm]] + (->VarConst @(:ns env) nm nm env)) (defmethod analyze-seq 'def - [[_ nm val :as form]] + [env [_ nm val :as form]] (->Def nm - (analyze-form val) + (analyze-form env val) form - *env*)) + env)) (defmethod analyze-seq 'quote - [[_ val]] + [env [_ val]] (if (map? val) (analyze-seq (with-meta `(pixie.stdlib/hashmap ~@(reduce @@ -281,30 +212,30 @@ [] val)) (meta val))) - (->Const val *env*))) + (->Const val env))) (defmethod analyze-seq 'in-ns - [[_ nsp]] - (reset! (:ns *env*) (symbol (name nsp))) + [env [_ nsp]] + (reset! (:ns env) (symbol (name nsp))) (in-ns nsp) (in-ns :pixie.compiler) - (analyze-form (list 'pixie.stdlib/-in-ns (keyword (name nsp))))) + (analyze-form env (list 'pixie.stdlib/-in-ns (keyword (name nsp))))) (defmethod analyze-seq 'local-macro - [[_ [nm replace] & body :as form]] - (binding [*env* (assoc-in *env* [:locals nm] {:op :local-macro - :name nm - :replace-with replace - :form form})] - (analyze-form (cons 'do body)))) + [env [_ [nm replace] & body :as form]] + (let [new-env (assoc-in env [:locals nm] {:op :local-macro + :name nm + :replace-with replace + :form form})] + (analyze-form new-env (cons 'do body)))) (defmethod analyze-form nil - [_] - (->Const nil *env*)) + [env _] + (->Const nil env)) (defmethod analyze-form :bool - [form] - (->Const form *env*)) + [env form] + (->Const form env)) (defn keep-meta [new old] (if-let [md (meta old)] @@ -314,75 +245,87 @@ new)) (defmethod analyze-seq :default - [[sym & args :as form]] - (let [resolved (try (and (symbol? sym) - (resolve-in (the-ns @(:ns *env*)) sym)) + [env [sym & args :as form]] + (let [sym (if (and (symbol? sym) + (= "pixie.bootstrap-macros" (namespace sym))) + (symbol (str "pixie.stdlib/" (name sym))) + sym) + bootstrap-resolved (when (and (symbol? sym) + (:bootstrap? env)) + (try (and (symbol? sym) + (resolve-in (the-ns :pixie.bootstrap-macros) (symbol (name sym)))) + (catch :pixie.stdlib/AssertionException ex + nil))) + resolved (try (and (symbol? sym) + (resolve-in (the-ns @(:ns env)) sym)) (catch :pixie.stdlib/AssertionException ex nil))] (cond (and (symbol? sym) (string/starts-with? (name sym) ".-")) (let [sym-kw (keyword (string/substring (name sym) 2)) - result (analyze-form (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw) - form))] + result (analyze-form env (keep-meta `(~'pixie.stdlib/-get-field ~@args ~sym-kw) + form))] result) - - (contains? macro-overrides resolved) - (analyze-form (keep-meta (apply (macro-overrides resolved) args) - form)) + + (and bootstrap-resolved + (macro? @bootstrap-resolved)) + (analyze-form env (keep-meta (apply @bootstrap-resolved args) + form)) (and resolved (macro? @resolved)) - (analyze-form (keep-meta (apply @resolved args) - form)) + (analyze-form env (keep-meta (apply @resolved args) + form)) :else - (->Invoke (binding [*env* (assoc *env* :tail? false)] - (analyze-form sym)) - (binding [*env* (assoc *env* :tail? false)] - (mapv analyze-form args)) - (:tail? *env*) + (->Invoke (let [new-env (assoc env :tail? false)] + (analyze-form new-env sym)) + (let [new-env (assoc env :tail? false)] + (mapv (partial analyze-form new-env) args)) + (:tail? env) form - *env*)))) + env)))) (defmethod analyze-form :number - [x] - (->Const x *env*)) + [env x] + (->Const x env)) (defmethod analyze-form :keyword - [x] - (->Const x *env*)) + [env x] + (->Const x env)) (defmethod analyze-form :string - [x] - (->Const x *env*)) + [env x] + (->Const x env)) (defmethod analyze-form :char - [x] - (->Const x *env*)) + [env x] + (->Const x env)) (defmethod analyze-form :seq - [x] - (analyze-seq x)) + [env x] + (analyze-seq env x)) (defmethod analyze-form :symbol - [x] - (if-let [local (get-in *env* [:locals x])] + [env x] + (if-let [local (get-in env [:locals x])] (if (= (:op local) :local-macro) - (analyze-form (:replace-with local)) + (analyze-form env (:replace-with local)) (assoc local :form x)) - (maybe-var x))) + (maybe-var env x))) (defmethod analyze-form :vector - [x] - (->Vector (mapv analyze-form x) + [env x] + (->Vector (mapv (partial analyze-form env) x) x - *env*)) + env)) (defmethod analyze-form :map - [x] - (analyze-seq (with-meta + [env x] + (analyze-seq env + (with-meta `(pixie.stdlib/hashmap ~@(reduce (fn [acc [k v]] (-> acc @@ -392,30 +335,35 @@ x)) (meta x)))) -(defn maybe-var [x] - (->Var @(:ns *env*) x x *env*)) +(defmethod analyze-form :set + [env x] + (analyze-seq env + (with-meta + `(pixie.stdlib/set ~(vec x)) + (meta x)))) + +(defn maybe-var [env x] + (->Var @(:ns env) x x env)) ;; ENV Functions (defn new-env "Creates a new (empty) environment" - [] + [bootstrap?] (->Env (atom 'pixie.stdlib) nil {} true - nil)) + nil + bootstrap?)) (defn analyze ([form] - (analyze form (new-env))) + (analyze form (new-env false))) ([form env] - (if *env* - (analyze-form form) - (binding [*env* env] - (analyze-form form))))) + (analyze-form env form))) diff --git a/pixie/reader.pxi b/pixie/reader.pxi new file mode 100644 index 00000000..bc0613b4 --- /dev/null +++ b/pixie/reader.pxi @@ -0,0 +1,310 @@ +(ns pixie.reader + (:require [pixie.string :as string])) + + +(defprotocol IPushbackReader + (read-ch [this]) + (unread-ch [this])) + +(defprotocol IMetadataReader + (metadata [this])) + +(deftype IndexedReader [s idx] + (read-ch [this] + (if (>= idx (count s)) + :eof + (let [ch (nth s idx)] + (set-field! this :idx (inc idx)) + ch))) + (unread-ch [this] + (set-field! this :idx (dec idx)))) + +(deftype UserSpaceReader [string-rdr reader-fn] + (read-ch [this] + (when-not string-rdr + (let [result (reader-fn)] + (if (eof? result) + (set-field! this :string-rdr :eof) + (set-field! this :string-rdr (->IndexedReader result 0))))) + + (if (eof? string-rdr) + :eof + (let [v (read-ch string-rdr)] + (if (eof? v) + (do (set-field! this :string-rdr nil) + (read-ch this)) + v)))) + (unread-ch [this] + (unread-ch string-rdr))) + +(defn user-space-reader [f] + (->UserSpaceReader nil f)) + + + + +(def whitespace? (contains-table \return \newline \, \space \tab)) + +(def digit? (apply contains-table "0123456789")) + +(defn eof? [x] + (identical? x :eof)) + +(defn terminating-macro? [ch] + (and (not= ch \#) + (not= ch \') + (not= ch \%) + (handlers ch))) + +(defn eat-whitespace [rdr] + (let [ch (read-ch rdr)] + (if (whitespace? ch) + (eat-whitespace rdr) + ch))) + +(defn assert-not-eof [ch msg] + (assert (not (identical? ch :eof)) msg)) + +(defn make-coll-reader [build-fn open-ch close-ch] + (fn rdr-internal + ([rdr] + (rdr-internal rdr [])) + ([rdr coll] + (let [ch (eat-whitespace rdr)] + #_(assert-not-eof ch (str "Unmatched delimiter " open-ch)) + (if (identical? ch close-ch) + (apply build-fn coll) + (let [_ (unread-ch rdr) + itm (read-inner rdr true false)] + (if (identical? itm rdr) + (rdr-internal rdr coll) + (rdr-internal rdr (conj coll itm))))))))) + + +(defn make-unmatched-handler [unhandled-ch] + (fn [rdr] + (throw [:pixie.reader/ParseError + (str "Unmatched delimiter " unhandled-ch)]))) + + +(def *gen-sym-env* (dynamic-var)) + +(defn syntax-quote-reader [rdr] + (let [form (read-inner rdr true)] + (with-handler [*gen-sym-env* *gen-sym-env*] + (reset! *gen-sym-env* {}) + (syntax-quote form)))) + +(defn unquote? [form] + (and (seq? form) + (= (first form) 'unquote))) + +(defn unquote-splicing? [form] + (and (seq? form) + (= (first form) 'unquote-splicing))) + +(defn syntax-quote [form] + (cond + (and (symbol? form) + nil ; TODO: Compiler special + ) + (list 'quote form) + + (symbol? form) + (if (not (namespace form) + (string/ends-with (name form) "#")) + (let [gmap @*gen-sym-env* + _ (assert gmap "Gensym literal used outside of a syntax quote") + gs (or (get gmap form) + (let [s (symbol (gensym (str (name form) "__")))] + (reset! *gen-sym-env* (assoc gmap form s))))] + (list 'quote gs)) + (list '-resolve-in form)) + + (unquote? form) + (first (next form)) + + (unquote-splicing? form) + (assert false "Unquote splicing used outside a list") + + (vector? form) + (list 'pixie.stdlib/apply 'pixie.apply/concat (expand-list form)) + + (and form (seq? form)) + (list 'pixie.stdlib/apply 'pixie.apply/list (expand-list form)) + + :else (list 'quote form))) + +(defn expand-list [form] + (reduce + (fn [acc itm] + (cond + (unquote? itm) + (conj acc [(nth form 1)]) + + (unquote-splicing? form) + (conj acc (nth form 1)) + + :else (conj acc [(syntax-quote form)]))) + [] + form)) + +(defn deref-reader [rdr] + (cons 'pixie.stdlib/deref (read-inner rdr true))) + + +(defn skip-line-reader [rdr] + (if (identical? \n (read-ch rdr)) + rdr + (skip-line rdr))) + +(defn meta-reader [rdr] + (let [m (read-inner rdr true) + o (read-inner rdr true) + m (cond + (keyword? m) {m true} + (symbol? m) {:tag m} + :else m)] + (if (has-meta? o) + (with-meta o m) + o))) + +(defn unquote-reader [rdr] + (let [ch (read-ch rdr) + sym (if (identical? ch \@) + 'pixie.stdlib/unquote-splicing + (do (unread-ch rdr) + 'pixie.stdlib/unquote)) + form (read-inner rdr true)] + (list sym form))) + +(def string-literals + (switch-table + \" \" + \\ \\ + \n \newline + \r \return + \t \tab)) + +(defn literal-string-reader [rdr] + (let [sb (string-builder) + sb-fn (fn [x] + (-add-to-string-builder sb x))] + (loop [] + (let [v (read-ch rdr)] + (cond + (eof? v) (throw [:pixie.reader/ParseError + "Unmatched string quote"]) + (identical? \" ch) (str sb) + + (identical? \\ ch) (let [v (read-ch rdr) + _ (when (eof? v) + (throw [:pixie.reader/ParseError + "End of file after escape character"])) + converted (string-literals v)] + (if converted + (do (sb-fn converted) + (recur)) + (throw [:pixie.reader/ParseError + (str "Unhandled escape character " v)]))) + :else (do (sb-fn v) + (recur))))))) + +(def handlers + (switch-table + \( (make-coll-reader list \( \)) + \[ (make-coll-reader vector \[ \]) + \{ (make-coll-reader hashmap \{ \}) + \] (make-unmatched-handler \]) + \) (make-unmatched-handler \)) + \} (make-unmatched-handler \}) + \` syntax-quote-reader + \@ deref-reader + \; skip-line-reader + \^ meta-reader + \~ unquote-reader)) + +(defn read-number [rdr ch] + (let [sb (string-builder) + sb-fn (fn [x] + (-add-to-string-builder sb x))] + (-str ch sb-fn) + (loop [sb-fn sb-fn] + (let [ch (read-ch rdr)] + (if (or (whitespace? ch) + (terminating-macro? ch) + (eof? ch)) + + (let [val (-parse-number (str sb))] + (unread-ch rdr) + (if val + val + (symbol val))) + (do (-str ch sb-fn) + (recur sb-fn))))))) + + +(defn read-symbol [rdr ch] + (let [sb (string-builder) + sb-fn (fn [x] + (-add-to-string-builder sb x))] + (-str ch sb-fn) + (loop [sb-fn sb-fn] + (let [ch (read-ch rdr)] + (if (or (whitespace? ch) + (terminating-macro? ch) + (eof? ch)) + + (let [val (interpret-symbol (str sb))] + (unread-ch rdr) + val) + (do (-str ch sb-fn) + (recur sb-fn))))))) + +(defn interpret-symbol [s] + (cond + (= s "true") true + (= s "false") false + (= s "nil") nil + :else (symbol s))) + + +(defn read-inner + ([rdr eof-on-error] + (read-inner rdr eof-on-error true)) + ([rdr eof-on-error always-return-form] + (let [ch (eat-whitespace rdr)] + (if (identical? ch :eof) + (if eof-on-error + (assert-not-eof ch "Unexpeced EOF while reading") + ch) + (let [m (when (satisfies? IMetadataReader rdr) + (metadata rdr)) + macro (handlers ch) + itm (cond + macro (let [itm (macro rdr)] + (if (and always-return-form + (identical? itm rdr)) + (read-inner rdr error-on-eof always-return-form) + itm)) + (digit? ch) (read-number rdr ch) + (identical? ch \-) (let [ch2 (read-ch rdr)] + (if (digit? ch2) + (do (unread-ch rdr) + (read-number rdr ch)) + (do (unread-ch rdr) + (read-symbol rdr ch)))) + :else (read-symbol rdr ch))] + (if (identical? itm rdr) + itm + (if (has-meta? itm) + (with-meta itm m) + itm))))))) + +(defn read [rdr error-on-eof] + (read-inner rdr error-on-eof)) + + +(defn read-string [s] + (read (->IndexedReader s 0) + false)) diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index f5426a04..da8bf380 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -2480,7 +2480,7 @@ and implements IAssociative, ILookup and IObject." 'ILookup `(-val-at [self k not-found] (if (contains? ~(set fields) k) - (. self k) + (get-field self k) not-found)) 'IObject `(-str [self] diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py index a67c065a..e85b10d1 100644 --- a/pixie/vm2/array.py +++ b/pixie/vm2/array.py @@ -49,6 +49,9 @@ def get_field(self, k): return rt.wrap(len(self._list)) return nil + def array_val(self): + return self._list + @as_var("array") def array__args(lst): return Array(lst) diff --git a/pixie/vm2/custom_types.py b/pixie/vm2/custom_types.py index 02149afc..abbffc20 100644 --- a/pixie/vm2/custom_types.py +++ b/pixie/vm2/custom_types.py @@ -1,5 +1,6 @@ from pixie.vm2.object import Object, Type, affirm, runtime_error import rpython.rlib.jit as jit +from pixie.vm2.primitives import nil from rpython.rlib.rarithmetic import r_uint from pixie.vm2.code import as_var from pixie.vm2.numbers import Integer, Float @@ -92,12 +93,11 @@ def get_field_immutable(self, idx): assert isinstance(tp, CustomType) return self._get_field_immutable(idx, tp._rev) - def get_field(self, name): + def get_field(self, name, not_found): idx = self._custom_type.get_slot_idx(name) assert isinstance(name, Keyword) if idx == -1: - runtime_error(u"Invalid field named " + rt.unwrap_keyword(name) + u" on type " + self._custom_type.custom_type_name(), - u"pixie.stdlib/InvalidFieldException") + return not_found if self._custom_type.is_mutable(name): value = self.get_field_by_idx(idx) @@ -235,11 +235,19 @@ def set_field(inst, field, val): return inst @as_var("get-field") -def get_field(inst, field): +def get_field__args(args): + if len(args) == 2: + inst, field = args + not_found = nil + elif len(args) == 3: + inst, field, not_found = args + else: + runtime_error(u"Get Field requires one or two args") + return nil + affirm(isinstance(inst, CustomTypeInstance), u"Can only get fields on CustomType instances") affirm(isinstance(field, Keyword), u"Field must be a keyword") - return inst.get_field(field) - + return inst.get_field(field, not_found) class AbstractMutableCell(Object): diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 52c4fea8..6716d026 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -1,5 +1,5 @@ from pixie.vm2.object import Object, Type, Continuation, stack_cons, runtime_error, affirm -from pixie.vm2.code import ns_registry +from pixie.vm2.code import ns_registry, as_var from pixie.vm2.primitives import nil, false from pixie.vm2.array import Array import pixie.vm2.code as code @@ -24,6 +24,10 @@ def get_long_location(self): return self._c_meta.get_long_location() return "" +@as_var("pixie.ast.internal", "->Meta") +def new_meta(line, file, line_number, column_number): + return Meta((line.get_name(), file.get_name(), line_number.int_val()), column_number.int_val()) + class Meta(Object): _type = Type(u"pixie.stdlib.Meta") _immutable_fields_ = ["_c_column_number", "_c_line_tuple"] @@ -73,10 +77,19 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast +@as_var("pixie.ast.internal", "->Const") +def new_const(val, meta): + print val, meta + return Const(val, meta) + @expose("_c_val") class Const(AST): _immutable_fields_ = ["_c_val"] _type = Type(u"pixie.interpreter.Const") + + def type(self): + return Const._type + def __init__(self, val, meta=nil): AST.__init__(self, meta) self._c_val = val @@ -110,6 +123,10 @@ def get_local(self, name): runtime_error(name.to_repr() + u" is undefined") return c._c_value +@as_var("pixie.ast.internal", "->Lookup") +def new_lookup(name, meta): + return Lookup(name, meta) + class Lookup(AST): _immutable_fields_ = ["_c_name"] def __init__(self, name, meta=nil): @@ -123,6 +140,10 @@ def interpret(self, _, locals, stack): def gather_locals(self): return {self._c_name: self._c_name} +as_var("pixie.ast.internal", "->Fn") +def new_fn(name, args, body, meta): + return Fn(name, args.array_val(), body, meta) + class Fn(AST): _immutable_fields_ = ["_c_name", "_c_args", "_c_body", "_c_closed_overs"] def __init__(self, name, args, body, closed_overs=[], meta=nil): @@ -209,9 +230,17 @@ def invoke_k_with(self, args, stack, self_fn): return nil, stack_cons(stack, InterpretK(self._c_fn_ast, locals)) +@as_var("pixie.ast.internal", "->Invoke") +def new_invoke(args, meta): + return Invoke(args.array_val(), meta) class Invoke(AST): _immutable_fields_ = ["_c_args", "_c_fn"] + _type = Type(u"pixie.ast-internal.Invoke") + + def type(self): + return Invoke._type + def __init__(self, args, meta=nil): AST.__init__(self, meta) self._c_args = args @@ -245,6 +274,10 @@ def get_ast(self): +@as_var("pixie.ast.internal", "->TailCall") +def new_invoke(args, meta): + return Invoke(args.array_val(), meta) + class TailCall(AST): _immutable_fields_ = ["_c_args", "_c_fn"] def __init__(self, args, meta=nil): @@ -293,6 +326,10 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_args[len(self._c_acc)] +@as_var("pixie.ast.internal", "->Let") +def new_let(names, bindings, body, meta): + return Let(names.array_val(), bindings.array_val(), body, meta) + class Let(AST): _immutable_fields_ = ["_c_names", "_c_bindings", "_c_body"] def __init__(self, names, bindings, body, meta=nil): @@ -311,7 +348,7 @@ def gather_locals(self): for x in self._c_names: if x in glocals: del glocals[x] - + return glocals def interpret(self, _, locals, stack): @@ -342,6 +379,10 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast +@as_var("pixie.ast.internal", "->If") +def new_if(test, then, els, meta): + return If(test, then, els, meta) + class If(AST): _immutable_fields_ = ["_c_test", "_c_then", "_c_else"] def __init__(self, test, then, els, meta=nil): @@ -379,6 +420,9 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast +@as_var("pixie.ast.internal", "->Do") +def new_do(args, meta): + return Do(args.array_val(), meta) class Do(AST): _immutable_fields_ = ["_c_body_asts"] @@ -418,13 +462,17 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast +@as_var("pixie.ast.internal", "->VDeref") +def new_vderef(in_ns, var_name, meta): + return VDeref(in_ns.get_name(), var_name, meta) + @expose("_c_var") class VDeref(AST): _immutable_fields_ = ["_c_in_ns", "_c_var_name"] def __init__(self, in_ns, var_name, meta=nil): AST.__init__(self, meta) self._c_in_ns = in_ns - self._c_var_ns = var_name.get_ns() + self._c_var_ns = None if var_name.get_ns() == u"" else var_name.get_ns() self._c_var_name = var_name.get_name() def interpret(self, val, locals, stack): @@ -437,7 +485,11 @@ def interpret(self, val, locals, stack): if var is not None: return var.deref(), stack else: - runtime_error(u"Var " + self._c_var_name + u" is undefined in " + self._c_in_ns, + runtime_error(u"Var " + + (self._c_var_ns + u"/" if self._c_var_ns else u"") + + self._c_var_name + + u" is undefined in " + + self._c_in_ns, u"pixie.stdlib/UndefinedVar") def gather_locals(self): @@ -612,6 +664,24 @@ def merge_dicts(a, b): return z +# Eval support + +class EvalFn(code.NativeFn): + + _type = Type(u"pixie.stdlib.EvalFn") + + def type(self): + return EvalFn._type + + + @jit.unroll_safe + def invoke_k(self, args, stack): + affirm(len(args) == 1, u"Eval takes one argument") + ast = args[0] + result = ast.interpret(nil, None, stack) + print "EVAL RESULT ", result + return result +as_var("pixie.ast.internal", "eval")(EvalFn()) diff --git a/pixie/vm2/keyword.py b/pixie/vm2/keyword.py index d7f6fb83..34956b8c 100644 --- a/pixie/vm2/keyword.py +++ b/pixie/vm2/keyword.py @@ -97,9 +97,9 @@ def keyword(nm, ns=None): # self._hash = util.hash_unencoded_chars(self._str) # return rt.wrap(intmask(self._hash)) # -# @as_var("keyword") -# def _keyword(s): -# if not isinstance(s, String): -# from pixie.vm.object import runtime_error -# runtime_error(u"Symbol name must be a string") -# return keyword(s._str) +@as_var("keyword") +def _keyword(s): + if not isinstance(s, String): + from pixie.vm2.object import runtime_error + runtime_error(u"Symbol name must be a string") + return keyword(s._str) diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index af53c735..e5a685df 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -321,4 +321,43 @@ def _var(ns, nm): ns = code.ns_registry.find_or_make(ns.get_name()) var = ns.resolve_in_ns_ex(nm.get_ns(), nm.get_name()) - return var if var is not None else nil \ No newline at end of file + return var if var is not None else nil + + +class PartialFunction(code.NativeFn): + _immutable_fields_ = ["_partial_f", "_partial_args"] + def __init__(self, f, args): + code.NativeFn.__init__(self) + self._partial_f = f + self._partial_args = args + + @jit.unroll_safe + def invoke_k(self, args, stack): + new_args = [None] * (len(args) + len(self._partial_args)) + + for x in range(len(self._partial_args)): + new_args[x] = self._partial_args[x] + + plen = len(self._partial_args) + + for x in range(len(args)): + new_args[plen + x] = args[x] + + + return self._partial_f.invoke_k(new_args, stack) + + +@as_var("partial") +@jit.unroll_safe +def _partial__args(args): + """(partial f & args) + Creates a function that is a partial application of f. Thus ((partial + 1) 2) == 3""" + + f = args[0] + + new_args = [None] * (len(args) - 1) + + for x in range(len(new_args)): + new_args[x] = args[x + 1] + + return PartialFunction(f, new_args) \ No newline at end of file From 1f7b2e43c68e6563cccce6089ace48e08ad21b76 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Fri, 3 Jul 2015 17:29:01 -0600 Subject: [PATCH 28/46] pixie can compile itself and then compile (+ 1 2) with the resulting compiler --- pixie/ast-output.pxi | 19 +++++++++++-------- pixie/ast.pxi | 8 ++++---- pixie/bootstrap-macros.pxi | 13 +++++-------- pixie/bootstrap.pxi | 18 ++++++++++++++++++ pixie/compiler.pxi | 6 ++---- pixie/pxic-writer.pxi | 3 +-- 6 files changed, 41 insertions(+), 26 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index dec03f06..a217f8d4 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -43,17 +43,20 @@ ast/Invoke (-to-ast [{:keys [args] :as ast}] - (let [args-array (make-array (inc (count args)))] - (aset args-array 0 (to-ast (:fn ast))) - (loop [idx 0] - (when (< idx (count args)) - (aset args-array - (inc idx) - (to-ast (nth args idx))) - (recur (inc idx)))) + (let [args-array (make-array (count args))] + (dotimes [idx (count args)] + (aset args-array idx + (to-ast (nth args idx)))) + (iast/->Invoke args-array (meta-ast ast)))) + ast/Var + (-to-ast [{:keys [ns var-name] :as ast}] + (iast/->VDeref (name ns) + var-name + (meta-ast ast))) + Object (-to-ast [this] diff --git a/pixie/ast.pxi b/pixie/ast.pxi index dcba61b7..26acfb18 100644 --- a/pixie/ast.pxi +++ b/pixie/ast.pxi @@ -55,10 +55,10 @@ (defrecord LocalMacro [name respace form env]) -(defrecord Invoke [fn args tail-call? form env] +(defrecord Invoke [args tail-call? form env] IAst (children-keys [this] - `[:fn :args])) + `[:args])) (defrecord Var [ns var-name form env] IAst @@ -85,8 +85,8 @@ ;; Ctors -(defn make-invoke-ast [fn args form env] - (->Invoke fn args false form env)) +(defn make-invoke-ast [f args form env] + (->Invoke (cons f args) false form env)) (defn make-var-ast [ns name env] (->Var ns name (symbol (pixie.stdlib/name name)) env)) diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index 7a5fd9ac..93bbb564 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -86,14 +86,11 @@ (do (assert (>= 1 (count (:require bmap))) "Only one :require block can be defined per namespace") - (println "NAme" (name nm)) (mapv (fn [r] `(require ~(keyword (name nm)) ~@r)) (first (:require bmap))))] `(do (in-ns ~(keyword (name nm))) - (println "in-ns " ~(keyword (name nm))) ~@requires))) (defmacro require [ins ns & args] - (println "ns " ins ns (vec args)) `(do (load-ns (quote ~ns)) (assert (the-ns (quote ~ns)) (str "Couldn't find the namespace " (quote ~ns) " after loading the file")) @@ -106,7 +103,7 @@ v-sym (gensym "v") this-sym (gensym "this") result `(-assoc [~this-sym ~k-sym ~v-sym] - (case ~k-sym + (condp identical? ~k-sym ~@(mapcat (fn [k] [k `(~cname ~@(mapv (fn [x] @@ -133,14 +130,14 @@ and implements IAssociative, ILookup and IObject." (apply ~ctor-name (map #(get m %) ~fields))) default-bodies ['IAssociative (-make-record-assoc-body ctor-name fields) - `(-contains-key [self k] - (contains? ~(set fields) k)) + `(-contains-key [self# k#] + (contains? ~(set fields) k#)) `(-dissoc [self k] (throw [:pixie.stdlib/NotImplementedException "dissoc is not supported on defrecords"])) 'ILookup - '(-val-at [self k not-found] - (get-field self k not-found)) + '(-val-at [self# k# not-found#] + (get-field self# k# not-found#)) 'IObject `(-str [self# sb#] (sb# (str "<" ~(name nm) " >" ))) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 63d04e79..35fa075c 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -346,6 +346,24 @@ ([mp k not-found] (-val-at mp k not-found))) +(defn get-in + {:doc "Get a value from a nested collection at the \"path\" given by the keys." + :examples [["(get-in {:a [{:b 42}]} [:a 0 :b])" nil 42]] + :signatures [[m ks] [m ks not-found]] + :added "0.1"} + ([m ks] + (reduce get m ks)) + ([m ks not-found] + (loop [sentinel 'x + m m + ks (seq ks)] + (if ks + (let [m (get m (first ks) sentinel)] + (if (identical? sentinel m) + not-found + (recur sentinel m (next ks)))) + m)))) + (defn contains? [mp k] (-contains-key mp k)) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 425dab9a..8e676935 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -280,9 +280,7 @@ :else (->Invoke (let [new-env (assoc env :tail? false)] - (analyze-form new-env sym)) - (let [new-env (assoc env :tail? false)] - (mapv (partial analyze-form new-env) args)) + (mapv (partial analyze-form new-env) form)) (:tail? env) form env)))) @@ -352,7 +350,7 @@ "Creates a new (empty) environment" [bootstrap?] (->Env - (atom 'pixie.stdlib) + (atom (symbol "pixie.stdlib")) nil {} true diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index c549bb36..2ac521f0 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -223,8 +223,7 @@ ast/Invoke (-write-object [{:keys [args] :as ast} os] (write-tag os INVOKE) - (write-int-raw os (inc (count args))) - (write-object os (:fn ast)) + (write-int-raw os (count args)) (doseq [arg args] (write-object os arg)) (write-meta os ast)) From 8bf578f335c408368f869b0ad52c36ff630bd5d8 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sat, 4 Jul 2015 15:26:56 -0600 Subject: [PATCH 29/46] some fixes to make translation work --- pixie/vm2/array.py | 4 +- pixie/vm2/code.py | 2 +- pixie/vm2/numbers.py | 88 ++++++++++++++++++++++---------------------- pixie/vm2/object.py | 4 +- pixie/vm2/rt.py | 55 +++++++++++++++------------ pixie/vm2/stdlib.py | 2 +- pixie/vm2/symbol.py | 2 +- target2.py | 6 ++- 8 files changed, 87 insertions(+), 76 deletions(-) diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py index e85b10d1..95ad9f71 100644 --- a/pixie/vm2/array.py +++ b/pixie/vm2/array.py @@ -44,10 +44,10 @@ def reduce_large(self, f, init): init = f.invoke([init, self._list[x]]) return init - def get_field(self, k): + def get_field(self, k, not_found): if k is KW_count: return rt.wrap(len(self._list)) - return nil + return not_found def array_val(self): return self._list diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index f77ca2a2..a6313980 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -448,7 +448,7 @@ def set_dynamic(self): def get_dynamic_value(self): - return _dynamic_vars.get_var_value(self, self._root) + return nil diff --git a/pixie/vm2/numbers.py b/pixie/vm2/numbers.py index 31227e7d..746e9a06 100644 --- a/pixie/vm2/numbers.py +++ b/pixie/vm2/numbers.py @@ -412,50 +412,50 @@ def eq(a, b): def init(): - import pixie.vm.stdlib as proto - from pixie.vm.string import String - - @extend(proto._str, Integer._type) - def _str(i): - return rt.wrap(unicode(str(i.int_val()))) - - @extend(proto._repr, Integer._type) - def _repr(i): - return rt.wrap(unicode(str(i.int_val()))) - - @extend(proto._str, BigInteger._type) - def _str(b): - return rt.wrap(unicode(b.bigint_val().format('0123456789', suffix='N'))) - - @extend(proto._repr, BigInteger._type) - def _repr(b): - return rt.wrap(unicode(b.bigint_val().format('0123456789', suffix='N'))) - - @extend(proto._str, Float._type) - def _str(f): - return rt.wrap(unicode(str(f.float_val()))) - - @extend(proto._repr, Float._type) - def _repr(f): - return rt.wrap(unicode(str(f.float_val()))) - - @extend(proto._repr, Ratio._type) - def _repr(r): - return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator()))) - - @extend(proto._str, Ratio._type) - def _str(r): - return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator()))) - - @as_var("numerator") - def numerator(r): - affirm(isinstance(r, Ratio), u"First argument must be a Ratio") - return rt.wrap(r.numerator()) - - @as_var("denominator") - def denominator(r): - affirm(isinstance(r, Ratio), u"First argument must be a Ratio") - return rt.wrap(r.denominator()) + import pixie.vm2.stdlib as proto + from pixie.vm2.string import String + + # @extend(proto._str, Integer._type) + # def _str(i): + # return rt.wrap(unicode(str(i.int_val()))) + # + # @extend(proto._repr, Integer._type) + # def _repr(i): + # return rt.wrap(unicode(str(i.int_val()))) + # + # @extend(proto._str, BigInteger._type) + # def _str(b): + # return rt.wrap(unicode(b.bigint_val().format('0123456789', suffix='N'))) + # + # @extend(proto._repr, BigInteger._type) + # def _repr(b): + # return rt.wrap(unicode(b.bigint_val().format('0123456789', suffix='N'))) + # + # @extend(proto._str, Float._type) + # def _str(f): + # return rt.wrap(unicode(str(f.float_val()))) + # + # @extend(proto._repr, Float._type) + # def _repr(f): + # return rt.wrap(unicode(str(f.float_val()))) + # + # @extend(proto._repr, Ratio._type) + # def _repr(r): + # return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator()))) + # + # @extend(proto._str, Ratio._type) + # def _str(r): + # return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator()))) + # + # @as_var("numerator") + # def numerator(r): + # affirm(isinstance(r, Ratio), u"First argument must be a Ratio") + # return rt.wrap(r.numerator()) + # + # @as_var("denominator") + # def denominator(r): + # affirm(isinstance(r, Ratio), u"First argument must be a Ratio") + # return rt.wrap(r.denominator()) from rpython.rlib.rsre import rsre_re as re # inspired by https://github.com/clojure/tools.reader/blob/9ee11ed/src/main/clojure/clojure/tools/reader/impl/commons.clj#L45 diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index 4268730f..419e9125 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -33,13 +33,13 @@ def r_uint_val(self): return 0 def hash(self): - import pixie.vm.rt as rt + import pixie.vm2.rt as rt return rt.wrap(compute_identity_hash(self)) def promote(self): return self - def get_field(self, k): + def get_field(self, k, not_found): runtime_error(u"Unsupported operation get-field") def to_str(self): diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index 96bf1fa1..aaec77d8 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -7,7 +7,7 @@ def init(): import pixie.vm2.code as code from pixie.vm2.object import affirm, _type_registry - from rpython.rlib.rarithmetic import r_uint + from rpython.rlib.rarithmetic import r_uint, base_int from rpython.rlib.rbigint import rbigint from pixie.vm2.primitives import nil, true, false from pixie.vm2.string import String @@ -57,30 +57,39 @@ def wrapper(*args): import pixie.vm2.ffi import pixie.vm2.platform + class FakeSpace(object): + def wrap(self, x): + if isinstance(x, Object): + return x + elif isinstance(x, bool): + return true if x else false + elif isinstance(x, int): + return numbers.Integer(x) + elif isinstance(x, rbigint): + return numbers.BigInteger(x) + elif isinstance(x, float): + return numbers.Float(x) + elif isinstance(x, unicode): + return String(x) + elif isinstance(x, py_str): + return String(unicode(x)) + + elif isinstance(x, r_uint): + from pixie.vm2.numbers import SizeT + return SizeT(x) + + + elif x is None: + return nil + else: + from pixie.vm2.object import runtime_error + return runtime_error(u"Bad Wrap") + wrap._annspecialcase_ = 'specialize:argtype(1)' + + space = FakeSpace() @specialize.argtype(0) def wrap(x): - if isinstance(x, bool): - return true if x else false - if isinstance(x, int): - return numbers.Integer(x) - if isinstance(x, rbigint): - return numbers.BigInteger(x) - if isinstance(x, float): - return numbers.Float(x) - if isinstance(x, unicode): - return String(x) - if isinstance(x, py_str): - return String(unicode(x)) - if isinstance(x, Object): - return x - if isinstance(x, r_uint): - return numbers.SizeT(x) - if x is None: - return nil - - if not we_are_translated(): - print x, type(x) - affirm(False, u"Bad wrap") + return space.wrap(x) globals()["wrap"] = wrap diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index e5a685df..b8fea56d 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -148,7 +148,7 @@ def _instance(c, o): @as_var("-internal-get-field") def _get_field(inst, k): - return inst.get_field(k) + return inst.get_field(k, nil) @as_var("identical?") def identical(a, b): diff --git a/pixie/vm2/symbol.py b/pixie/vm2/symbol.py index 3133a130..6f753857 100644 --- a/pixie/vm2/symbol.py +++ b/pixie/vm2/symbol.py @@ -97,7 +97,7 @@ def symbol(s): @as_var("symbol") def _symbol(s): if not isinstance(s, String): - from pixie.vm.object import runtime_error + from pixie.vm2.object import runtime_error runtime_error(u"Symbol name must be a string") return symbol(s.get_name()) # diff --git a/target2.py b/target2.py index 1e8cdf9a..ff35e5ec 100644 --- a/target2.py +++ b/target2.py @@ -9,6 +9,7 @@ from pixie.vm2.symbol import symbol as sym from pixie.vm2.numbers import parse_number from pixie.vm2.pxic_reader import read_file, read_object, Reader +from rpython.rlib.objectmodel import we_are_translated rt.init() import sys @@ -20,8 +21,9 @@ def testit(max): obj = read_object(rdr) except EOFError: break - print ".", - sys.stdout.flush() + if not we_are_translated(): + print ".", + sys.stdout.flush() run_stack(None, i.InterpretK(obj, None)) return None From dcce84e96be6a7ad751da11bb79f9b98ddf728df Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 6 Jul 2015 23:08:41 -0600 Subject: [PATCH 30/46] metadata reader fixes to sequence, more compiler bugfixes --- pixie/ast-output.pxi | 20 +++++-- pixie/ast.pxi | 10 +++- pixie/bootstrap-macros.pxi | 17 +----- pixie/bootstrap.pxi | 106 ++++++++++++++++++++++++++++--------- pixie/compiler.pxi | 3 +- pixie/reader.pxi | 42 +++++++++++++++ pixie/vm2/stdlib.py | 29 +++++++++- pixie/vm2/string.py | 4 +- 8 files changed, 179 insertions(+), 52 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index a217f8d4..59aed758 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -6,10 +6,21 @@ (-to-ast [this])) (defn meta-ast [ast] - nil) + (let [{:keys [line file line-number column-number] :as m} (or (meta (:form ast)) + (:meta (:env ast))) + line (if (string? line) + line + (apply str @line))] + + (iast/->Meta (or line + "") + (or file + "") + (or line-number -1) + (or column-number 1)))) (defn to-ast [this] - (-to-ast this)) + (-to-ast (simplify this))) (extend-protocol ToNativeAST @@ -43,6 +54,7 @@ ast/Invoke (-to-ast [{:keys [args] :as ast}] + (println "INVOKE > " (count args) args) (let [args-array (make-array (count args))] (dotimes [idx (count args)] (aset args-array idx @@ -60,7 +72,7 @@ Object (-to-ast [this] - (println this) + (println "Encoding" this "of type" (type this)) (throw [:pixie.stdlib/IllegalArgumentException (str "Can't encode " this)]))) @@ -68,6 +80,6 @@ (let [simplified (ast/simplify-ast ast)] (if (identical? simplified ast) ast - (recur simplified)))) + (simplify simplified)))) diff --git a/pixie/ast.pxi b/pixie/ast.pxi index 26acfb18..32f25a53 100644 --- a/pixie/ast.pxi +++ b/pixie/ast.pxi @@ -154,9 +154,17 @@ Vector (simplify-ast [{:keys [items form env]}] + (if (not (:bootstrap? env)) + (println "Vector > " items + (seq items) + (count (seq items)) + (first (seq items)) + (first (next (seq items))))) (make-invoke-var-ast "pixie.stdlib" - (symbol "array") + (if (:bootstrap? env) + (symbol "array") + (symbol "vector")) items form env)) diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index 93bbb564..ef9f51d2 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -32,21 +32,6 @@ rest fields)] `(fn ~(symbol (str fn-name "_" nm)) ~args ~@body))) - bodies (reduce - (fn [res body] - (cond - (symbol? body) (cond - (= body 'Object) [body (second res) (third res)] - :else [body - (second res) - (conj (third res) body)]) - (seq? body) (let [proto (first res) tbs (second res) pbs (third res)] - (if (protocol? proto) - [proto tbs (conj pbs body)] - [proto (conj tbs body) pbs])))) - [nil [] []] - body) - proto-bodies (second bodies) all-fields fields type-nm (str #_@(:ns env) "." (name nm)) type-decl `(def ~nm (create-type ~(keyword type-nm) @@ -64,7 +49,7 @@ ~(mk-body body)) :else (assert false "Unknown body element in deftype, expected symbol or seq")))) conj - proto-bodies)] + body)] `(do ~type-decl ~ctor ~@proto-bodies))) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 35fa075c..a101585e 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -132,7 +132,8 @@ (-run-external-extends) (extend -get-field Object -internal-get-field) - +(extend -hash Object -internal-identity-hash) +(extend -meta Object (fn [x] nil)) (extend-type Object (-str [x sb] @@ -288,7 +289,7 @@ {:doc "Adds elements to the transient collection. Elements are added to the end except in the case of Cons lists" :signatures [[] [coll] [coll item] [coll item & args]] :added "0.1"} - ([] (-transient [])) + ([] (-transient pixie.stdlib.persistent-vector/EMPTY)) ([coll] (-persistent! coll)) ([coll item] (-conj! coll item)) ([coll item & args] @@ -395,7 +396,15 @@ (-with-meta x m)) (defn count - ([coll] (-count coll))) + ([coll] + (if (counted? coll) + (-count coll) + (loop [s (seq coll) + i 0] + (if (counted? s) + (+ i (count s)) + (recur (next s) + (inc i))))))) (defn assoc {:doc "Associates the key with the value in the collection" @@ -476,19 +485,42 @@ ;; Cons and List -(deftype Cons [first next meta] +(deftype Cons [head tail meta] ISeq - (-first [this] first) - (-next [this] next) + (-first [this] head) + (-next [this] tail) ISeqable (-seq [this] this) IMeta (-meta [this] meta) (-with-meta [this new-meta] - (->Cons first next new-meta))) + (->Cons head tail new-meta)) + + IIndexed + (-nth [self idx] + (loop [i idx + s (seq self)] + (if (or (= i 0) + (nil? s)) + (if (nil? s) + (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"]) + (first s)) + (recur (dec i) + (next s))))) + + (-nth-not-found [self idx not-found] + (loop [i idx + s (seq self)] + (if (or (= i 0) + (nil? s)) + (if (nil? s) + (first s) + not-found) + (recur (dec i) + (next s)))))) (defn cons [head tail] - (->Cons head (seq tail) nil)) + (->Cons head tail nil)) (deftype List [head tail cnt hash-val meta] @@ -515,7 +547,7 @@ this)) (sb ")")) - + IIndexed (-nth [self idx] @@ -527,7 +559,7 @@ (first s) (throw [:pixie.stdlib/OutOfRangeException "Index out of Range"])) (recur (dec i) - (next s))))1) + (next s))))) (-nth-not-found [self idx not-found] (loop [i idx @@ -535,10 +567,11 @@ (if (or (= i 0) (nil? s)) (if (nil? s) - (first s) - not-found) - (recur (dec i)0 + not-found + (first s)) + (recur (dec i) (next s))))) + IReduce (-reduce [this f init] @@ -558,7 +591,7 @@ IMeta (-meta [this] meta) (-with-meta [this new-meta] - (->List head tail cnt hash-val meta)) + (->List head tail cnt hash-val new-meta)) IPersistentCollection (-conj [this val] @@ -630,21 +663,28 @@ (deftype Generator [] IEffect (-effect-val [this val] + (println "DONE GENERATOR") nil) (-effect-finally [this val] + (println "FINALLY GENERATOR") val) EGenerator (-yield [this val k] - (cons val (lazy-seq - (with-handler [_ this] - (k nil)))))) + (let [v (cons val (lazy-seq + (println "calling k") + (k nil)))] + (println "return v") + v))) (defn yield [g i] + (println "YIELDING " i) (-yield g i) + (println "DONE YIELDING " i) g) (defn sequence [coll] + (println "----- START --- ") (with-handler [gen (->Generator)] (reduce yield gen coll))) @@ -848,6 +888,15 @@ (transduce xform conj! (transient to) from) (transduce xform conj to from)))) +(defn vec + {:doc "Converts a reducable collection into a vector using the (optional) transducer." + :signatures [[coll] [xform coll]] + :added "0.1"} + ([coll] + (transduce conj coll)) + ([xform coll] + (transduce xform conj coll))) + (defn map ^{:doc "map - creates a transducer that applies f to every input element" :signatures [[f] [f coll]] @@ -1242,7 +1291,7 @@ -(defn tailoff [this] +(defn tail-off [this] (let [cnt (.-cnt this)] (if (< cnt 32) 0 @@ -1250,7 +1299,7 @@ (defn array-for [this i] (if (and (<= 0 i) (< i (.-cnt this))) - (if (>= i (tailoff this)) + (if (>= i (tail-off this)) (.-tail this) (loop [node (.-root this) level (.-shift this)] @@ -1286,6 +1335,8 @@ this)) (sb "]")) + IVector + ISeqable (-seq [this] (sequence this)) @@ -1299,7 +1350,7 @@ (-conj [this val] (assert (< cnt 0xFFFFFFFF) "Vector too large") - (if (< (- cnt (tailoff this)) 32) + (if (< (- cnt (tail-off this)) 32) (let [new-tail (array-append tail val)] (->PersistentVector (inc cnt) shift root new-tail hash-val meta)) @@ -1355,7 +1406,7 @@ (if (= cnt 1) EMPTY - (if (> (- cnt (tailoff this)) 1) + (if (> (- cnt (tail-off this)) 1) (let [size (dec (count tail)) new-tail (array-resize tail size)] (->PersistentVector (dec cnt) @@ -1514,7 +1565,7 @@ (-conj! [this val] (ensure-editable this) (let [i cnt] - (if (< (- i (tail-off this) 32)) + (if (< (- i (tail-off this)) 32) (do (aset tail (bit-and i 0x01F) val) (set-field! this :cnt (inc cnt)) this) @@ -1546,7 +1597,7 @@ (->Node edited (array-clone (.-array node)))) (defn ensure-editable [node] - (assert (not (nil? (.-edit node))) + (assert (nil? (.-edit node)) "Transient used after call to persist!")) (defn ensure-node-editable [this node] @@ -1557,7 +1608,7 @@ (defn editable-tail [tail] (let [ret (make-array 32)] - (acopy tail 0 ret 0 (count tail)) + (array-copy tail 0 ret 0 (count tail)) ret)) (in-ns :pixie.stdlib) @@ -1779,8 +1830,6 @@ IMeta (-meta [this] meta) - - IWithMeta (-with-meta [this new-meta] (->PersistentHashMap cnt root has-nil? nil-val hash-val new-meta)) @@ -2049,6 +2098,11 @@ 1000000) (-eq [this other] (identical? this other)) + + ILookup + (-val-at + ([this k] nil) + ([this k not-found] nil)) IDeref (-deref [this] diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 8e676935..ffb3bb7d 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -17,7 +17,8 @@ (keyword? x) :keyword (map? x) :map (set? x) :set - :else (type x)))) + :else (do (println "Cant' Analyze " x) + (assert false "Can't analyze"))))) (defmulti analyze-seq (fn [_ x] (let [f (first x)] diff --git a/pixie/reader.pxi b/pixie/reader.pxi index bc0613b4..97a363ed 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -10,6 +10,7 @@ (metadata [this])) (deftype IndexedReader [s idx] + IPushbackReader (read-ch [this] (if (>= idx (count s)) :eof @@ -20,6 +21,7 @@ (set-field! this :idx (dec idx)))) (deftype UserSpaceReader [string-rdr reader-fn] + IPushbackReader (read-ch [this] (when-not string-rdr (let [result (reader-fn)] @@ -41,6 +43,44 @@ (->UserSpaceReader nil f)) +(deftype MetaDataReader [parent-reader line-number column-number line + prev-line-number prev-column-number prev-line prev-chr + filename has-unread cur-chr] + IPushbackReader + (read-ch [this] + (if has-unread + (do (set-field! this :has-unread false) + prev-chr) + (let [ch (read-ch parent-reader)] + (set-field! this :prev-column-number column-number) + (set-field! this :prev-line-number line-number) + (set-field! this :prev-line prev-line) + (when (string? line) + (set-field! this :line (atom []))) + (if (identical? ch \n) + (do (swap! line (fn [x] (apply str x))) + (set-field! this :line-number (inc line-number)) + (set-field! this :column-number 0)) + (do (swap! line conj ch) + (set-field! this :column-number (inc column-number)))) + + (set-field! this :cur-chr ch) + ch))) + + (unread-ch [this] + (assert (not has-unread) "Can't unread twice") + (set-field! this :has-unread true) + (set-field! this :prev-chr cur-chr)) + + IMetadataReader + (metadata [this] + {:line line + :line-number line-number + :column-number column-number + :file filename})) + +(defn metadata-reader [parent file] + (->MetaDataReader parent 1 0 (atom []) 1 0 nil \0 file false \0)) (def whitespace? (contains-table \return \newline \, \space \tab)) @@ -280,6 +320,7 @@ ch) (let [m (when (satisfies? IMetadataReader rdr) (metadata rdr)) + _ (println "METADATA " m) macro (handlers ch) itm (cond macro (let [itm (macro rdr)] @@ -295,6 +336,7 @@ (do (unread-ch rdr) (read-symbol rdr ch)))) :else (read-symbol rdr ch))] + (println "HAS ET " (type itm) (has-meta? itm)) (if (identical? itm rdr) itm (if (has-meta? itm) diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index b8fea56d..98275ee7 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -1,5 +1,5 @@ import pixie.vm2.rt as rt -from pixie.vm2.code import as_var, Var, list_copy, NativeFn +from pixie.vm2.code import as_var, Var, list_copy, NativeFn, extend_var from pixie.vm2.numbers import SizeT from pixie.vm2.object import affirm, Type, runtime_error from pixie.vm2.primitives import nil, true, false @@ -180,6 +180,12 @@ def _internal_store_hash(x, h): x.store_hash(h.r_uint_val()) return nil +@as_var("-internal-identity-hash") +def _internal_identity_hash(x): + from rpython.rlib.objectmodel import compute_identity_hash + return rt.wrap(compute_identity_hash(x)) + + @as_var("-internal-int") def _internal_int(x): return rt.wrap(x.int_val()) @@ -321,6 +327,7 @@ def _var(ns, nm): ns = code.ns_registry.find_or_make(ns.get_name()) var = ns.resolve_in_ns_ex(nm.get_ns(), nm.get_name()) + print "Resolved ", ns, nm.get_name(), var return var if var is not None else nil @@ -360,4 +367,22 @@ def _partial__args(args): for x in range(len(new_args)): new_args[x] = args[x + 1] - return PartialFunction(f, new_args) \ No newline at end of file + return PartialFunction(f, new_args) + +from pixie.vm2.code import BaseCode + +@as_var("set-macro!") +def set_macro(f): + affirm(isinstance(f, BaseCode), u"Only code objects can be macros") + f.set_macro() + return f + +@as_var("macro?") +def macro_QMARK_(f): + return true if isinstance(f, BaseCode) and f.is_macro() else false + + +@extend_var("pixie.stdlib", "-deref", Var) +def __deref(self): + assert isinstance(self, Var) + return self.deref() \ No newline at end of file diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index 82d1d445..fad30796 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -222,11 +222,11 @@ def char(val): # return rt.wrap(intmask(util.hash_unencoded_chars(self._str))) -@as_var("pixie.string", "starts-with") +@as_var("pixie.string", "starts-with?") def startswith(a, b): return rt.wrap(a.get_name().startswith(b.get_name())) -@as_var("pixie.string", "ends-with") +@as_var("pixie.string", "ends-with?") def endswith(a, b): return rt.wrap(a.get_name().endswith(b.get_name())) From 36a3923fed18edec0c525f24252e95bafcfd07c7 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 7 Jul 2015 16:57:23 -0600 Subject: [PATCH 31/46] fixed bugs with do and macros, can compile when now --- pixie/ast-output.pxi | 33 +++++++++++++++++++++---------- pixie/bootstrap-macros.pxi | 16 ++++++++++++++- pixie/bootstrap.pxi | 33 ++++++++++++++++++++----------- pixie/compile-bootstrap.pxi | 2 +- pixie/compiler.pxi | 12 ++++++++---- pixie/reader.pxi | 4 +--- pixie/vm2/interpreter.py | 11 ++++++++++- pixie/vm2/symbol.py | 39 ++++++++++++++++++------------------- 8 files changed, 99 insertions(+), 51 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index 59aed758..e6722e7e 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -26,20 +26,33 @@ ast/If (-to-ast [{:keys [test then else] :as ast}] - (ast/->If (to-ast test) - (to-ast then) - (to-ast else) - (meta-ast ast))) + (iast/->If (to-ast test) + (to-ast then) + (to-ast else) + (meta-ast ast))) ast/Let (-to-ast [{:keys [bindings body] :as ast}] - (ast/->Let (apply array (map #(keyword (name (:name %))) - bindings)) - (apply array (map #(to-ast :value %) - bindings)) - (to-ast body) - (meta-ast ast))) + (iast/->Let (apply array (map #(keyword (name (:name %))) + bindings)) + (apply array (map #(to-ast :value %) + bindings)) + (to-ast body) + (meta-ast ast))) + ast/Do + (-to-ast [{:keys [statements ret] :as ast}] + (println "DO " statements ret) + (let [args-array (make-array (inc (count statements)))] + (dotimes [idx (count statements)] + (aset args-array idx + (to-ast (nth statements idx)))) + + (aset args-array (count statements) + (to-ast ret)) + + (iast/->Do args-array + (meta-ast ast)))) ast/LetBinding (-to-ast diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index ef9f51d2..31eb69a0 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -121,7 +121,7 @@ and implements IAssociative, ILookup and IObject." (throw [:pixie.stdlib/NotImplementedException "dissoc is not supported on defrecords"])) 'ILookup - '(-val-at [self# k# not-found#] + `(-val-at [self# k# not-found#] (get-field self# k# not-found#)) 'IObject `(-str [self# sb#] @@ -136,3 +136,17 @@ and implements IAssociative, ILookup and IObject." deftype-decl `(deftype ~nm ~fields ~@default-bodies ~@body)] `(do ~type-from-map ~deftype-decl))) + +(defmacro when [test & body] + `(if ~test (do ~@body))) + +(defmacro when-not [test & body] + `(if (not ~test) (do ~@body))) + +(defmacro when-let [binding & body] + (let [bind (nth binding 0 nil) + test (nth binding 1 nil)] + `(let [tmp# ~test] + (when tmp# + (let [~bind tmp#] + ~@body))))) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index a101585e..c8d65fb3 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -426,10 +426,20 @@ (-seq x)) (defn first [x] - (-first (seq x))) + (if (satisfies? ISeq x) + (-first x) + (let [x (seq x)] + (if (nil? x) + nil + (-first x))))) (defn next [x] - (-next (seq x))) + (if (satisfies? ISeq x) + (seq (-next x)) + (let [x (seq x)] + (if (nil? x) + nil + (seq (-next x)))))) (defn nthnext {:doc "Returns the result of calling next n times on the collection." @@ -463,7 +473,7 @@ (nth coll (dec (count coll))) (loop [coll coll] (if-let [v (next coll)] - v + (recur v) (first coll))))) (defn butlast [coll] @@ -496,6 +506,10 @@ (-with-meta [this new-meta] (->Cons head tail new-meta)) + IReduce + (-reduce [this f init] + (seq-reduce this f init)) + IIndexed (-nth [self idx] (loop [i idx @@ -663,28 +677,21 @@ (deftype Generator [] IEffect (-effect-val [this val] - (println "DONE GENERATOR") nil) (-effect-finally [this val] - (println "FINALLY GENERATOR") val) EGenerator (-yield [this val k] (let [v (cons val (lazy-seq - (println "calling k") (k nil)))] - (println "return v") v))) (defn yield [g i] - (println "YIELDING " i) (-yield g i) - (println "DONE YIELDING " i) g) (defn sequence [coll] - (println "----- START --- ") (with-handler [gen (->Generator)] (reduce yield gen coll))) @@ -1187,7 +1194,11 @@ (if (< idx (count this)) (recur (inc idx) (f acc (aget this idx))) - acc))))) + acc)))) + + ISeqable + (-seq [this] + (sequence this))) (defn array-copy [from from-idx to to-idx size] (loop [idx 0] diff --git a/pixie/compile-bootstrap.pxi b/pixie/compile-bootstrap.pxi index 6c67eda2..bd062415 100644 --- a/pixie/compile-bootstrap.pxi +++ b/pixie/compile-bootstrap.pxi @@ -36,7 +36,7 @@ (dispose! os))) (compile-files ["pixie/bootstrap.pxi" - #_"pixie/bootstrap-macros.pxi" + "pixie/bootstrap-macros.pxi" "pixie/streams.pxi" "pixie/io-blocking.pxi" "pixie/reader.pxi" diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index ffb3bb7d..0fb055d0 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -217,10 +217,14 @@ (defmethod analyze-seq 'in-ns [env [_ nsp]] - (reset! (:ns env) (symbol (name nsp))) - (in-ns nsp) - (in-ns :pixie.compiler) - (analyze-form env (list 'pixie.stdlib/-in-ns (keyword (name nsp))))) + (let [nsp (if (and (:bootstrap? env) + (= (name nsp) "pixie.bootstrap-macros")) + (symbol "pixie.stdlib") + nsp)] + (reset! (:ns env) (symbol (name nsp))) + (in-ns nsp) + (in-ns :pixie.compiler) + (analyze-form env (list 'pixie.stdlib/-in-ns (keyword (name nsp)))))) (defmethod analyze-seq 'local-macro [env [_ [nm replace] & body :as form]] diff --git a/pixie/reader.pxi b/pixie/reader.pxi index 97a363ed..bc0e7a43 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -55,7 +55,7 @@ (set-field! this :prev-column-number column-number) (set-field! this :prev-line-number line-number) (set-field! this :prev-line prev-line) - (when (string? line) + (when (string? @line) (set-field! this :line (atom []))) (if (identical? ch \n) (do (swap! line (fn [x] (apply str x))) @@ -320,7 +320,6 @@ ch) (let [m (when (satisfies? IMetadataReader rdr) (metadata rdr)) - _ (println "METADATA " m) macro (handlers ch) itm (cond macro (let [itm (macro rdr)] @@ -336,7 +335,6 @@ (do (unread-ch rdr) (read-symbol rdr ch)))) :else (read-symbol rdr ch))] - (println "HAS ET " (type itm) (has-meta? itm)) (if (identical? itm rdr) itm (if (has-meta? itm) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 6716d026..8b55a385 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -385,6 +385,11 @@ def new_if(test, then, els, meta): class If(AST): _immutable_fields_ = ["_c_test", "_c_then", "_c_else"] + _type = Type(u"pixie.ast-internal.If") + + def type(self): + return If._type + def __init__(self, test, then, els, meta=nil): AST.__init__(self, meta) self._c_test = test @@ -426,6 +431,11 @@ def new_do(args, meta): class Do(AST): _immutable_fields_ = ["_c_body_asts"] + _type = Type(u"pixie.ast-internal.Do") + + def type(self): + return Do._type + def __init__(self, args, meta=nil): AST.__init__(self, meta) self._c_body_asts = args @@ -680,7 +690,6 @@ def invoke_k(self, args, stack): ast = args[0] result = ast.interpret(nil, None, stack) - print "EVAL RESULT ", result return result as_var("pixie.ast.internal", "eval")(EvalFn()) diff --git a/pixie/vm2/symbol.py b/pixie/vm2/symbol.py index 6f753857..876b6aac 100644 --- a/pixie/vm2/symbol.py +++ b/pixie/vm2/symbol.py @@ -1,6 +1,6 @@ import pixie.vm2.object as object from pixie.vm2.primitives import nil, true, false -from pixie.vm2.code import extend, as_var +from pixie.vm2.code import extend_var, as_var from pixie.vm2.string import String import pixie.vm2.rt as rt #import pixie.vm2.util as util @@ -63,13 +63,14 @@ def get_hash(self): def symbol(s): return Symbol(s) # -# @extend(proto._eq, Symbol) -# def _eq(self, other): -# assert isinstance(self, Symbol) -# if not isinstance(other, Symbol): -# return false -# return true if self._str == other._str else false -# +@extend_var("pixie.stdlib", "-eq", Symbol) +def _eq(self, other): + assert isinstance(self, Symbol) + if not isinstance(other, Symbol): + return false + return true if self._str == other._str else false + + # @extend(proto._str, Symbol) # def _str(self): # assert isinstance(self, Symbol) @@ -100,15 +101,13 @@ def _symbol(s): from pixie.vm2.object import runtime_error runtime_error(u"Symbol name must be a string") return symbol(s.get_name()) -# -# -# -# @extend(proto._meta, Symbol) -# def _meta(self): -# assert isinstance(self, Symbol) -# return self.meta() -# -# @extend(proto._with_meta, Symbol) -# def _with_meta(self, meta): -# assert isinstance(self, Symbol) -# return self.with_meta(meta) + +@extend_var("pixie.stdlib", "-meta", Symbol) +def _meta(self): + assert isinstance(self, Symbol) + return self.meta() + +@extend_var("pixie.stdlib", "-with-meta", Symbol) +def _with_meta(self, meta): + assert isinstance(self, Symbol) + return self.with_meta(meta) From 2eb7d3b0b801f142263d04ba616061dd9f99d70f Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 7 Jul 2015 22:57:21 -0600 Subject: [PATCH 32/46] more work on macros, added odd?, even? and mod support --- pixie/bootstrap-macros.pxi | 3 ++ pixie/bootstrap.pxi | 83 +++++++++++++++++++++++++++++++++++++- pixie/reader.pxi | 9 +++-- pixie/vm2/numbers.py | 4 ++ pixie/vm2/stdlib.py | 4 +- 5 files changed, 97 insertions(+), 6 deletions(-) diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index 31eb69a0..b7a8c480 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -72,6 +72,7 @@ (assert (>= 1 (count (:require bmap))) "Only one :require block can be defined per namespace") (mapv (fn [r] `(require ~(keyword (name nm)) ~@r)) (first (:require bmap))))] + `(do (in-ns ~(keyword (name nm))) ~@requires))) @@ -150,3 +151,5 @@ and implements IAssociative, ILookup and IObject." (when tmp# (let [~bind tmp#] ~@body))))) + + diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index c8d65fb3..5cf251d8 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -184,6 +184,12 @@ ([x y & args] (reduce -div (-div x y) args))) +(defn quot [num div] + (-quot num div)) + +(defn rem [num div] + (-rem num div)) + (defn inc ([x] (+ x 1))) @@ -250,6 +256,20 @@ [x] (= x 0)) +(defn even? + {:doc "Returns true if n is even" + :signatures [[n]] + :added "0.1"} + [n] + (zero? (rem n 2))) + +(defn odd? + {:doc "Returns true of n is odd" + :signatures [[n]] + :added "0.1"} + [n] + (= (rem n 2) 1)) + ;; Base functions @@ -496,6 +516,20 @@ ;; Cons and List (deftype Cons [head tail meta] + IObject + (-str [this sb] + (sb "(") + (let [not-first (atom false)] + (reduce + (fn [_ x] + (if @not-first + (sb " ") + (reset! not-first true)) + (-str x sb)) + nil + this)) + (sb ")")) + ISeq (-first [this] head) (-next [this] tail) @@ -1237,7 +1271,9 @@ IAtom (-swap! [this f args] - (-reset! this (apply f @this args))) + (let [new-val (apply f @this args)] + (-reset! this new-val) + new-val)) (-reset! [this val] (set-field! this :value val))) @@ -2350,3 +2386,48 @@ user => (refer 'pixie.string :exclude '(substring))" ;; + + +(def gensym-state (atom 0)) +(defn gensym + ([] (gensym "auto_")) + ([prefix] (symbol (str prefix (swap! gensym-state inc))))) + + +;; Macros + +(defmacro fn + {:doc "Creates a function. + +The following two forms are allowed: + (fn name? [param*] & body) + (fn name? ([param*] & body)+) + +The params can be destructuring bindings, see `(doc let)` for details."} + [& decls] + (println "FN" (seq decls)) + (let [name (if (symbol? (first decls)) [(first decls)] nil) + decls (if name (next decls) decls) + decls (cond + (vector? (first decls)) (list decls) + ;(satisfies? ISeqable (first decls)) decls + ;:else (throw (str "expected a vector or a seq, got a " (type decls))) + :else decls) + _ (println ">>>" name decls) + decls (seq (map (fn [[argv & body]] + (let [names (vec (map #(if (= % '&) '& (gensym "arg__")) argv)) + bindings (loop [i 0 bindings []] + (if (< i (count argv)) + (if (= (nth argv i) '&) + (recur (inc i) bindings) + (recur (inc i) (reduce conj bindings [(nth argv i) (nth names i)]))) + bindings))] + (if (every? symbol? argv) + `(~argv ~@body) + `(~names + (let ~bindings + ~@body))))) + decls))] + (if (= (count decls) 1) + `(fn* ~@name ~(first (first decls)) ~@(next (first decls))) + `(fn* ~@name ~@decls)))) diff --git a/pixie/reader.pxi b/pixie/reader.pxi index bc0e7a43..74660f67 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -231,9 +231,9 @@ sb-fn (fn [x] (-add-to-string-builder sb x))] (loop [] - (let [v (read-ch rdr)] + (let [ch (read-ch rdr)] (cond - (eof? v) (throw [:pixie.reader/ParseError + (eof? ch) (throw [:pixie.reader/ParseError "Unmatched string quote"]) (identical? \" ch) (str sb) @@ -247,7 +247,7 @@ (recur)) (throw [:pixie.reader/ParseError (str "Unhandled escape character " v)]))) - :else (do (sb-fn v) + :else (do (sb-fn ch) (recur))))))) (def handlers @@ -262,7 +262,8 @@ \@ deref-reader \; skip-line-reader \^ meta-reader - \~ unquote-reader)) + \~ unquote-reader + \" literal-string-reader)) (defn read-number [rdr ch] (let [sb (string-builder) diff --git a/pixie/vm2/numbers.py b/pixie/vm2/numbers.py index 746e9a06..076488ab 100644 --- a/pixie/vm2/numbers.py +++ b/pixie/vm2/numbers.py @@ -174,6 +174,10 @@ def ratio_read(obj): SizeT: "{x} / {y}", BigInteger: "{x}.div({y})", Float: "{x} / {y}"}, + "-rem": {Integer: "{x} % {y}", + SizeT: "{x} % {y}", + BigInteger: "{x}.mod({y})", + Float: "math.fmod({x}, {y})"}, "-gt": {Integer: "{x} > {y}", SizeT: "{x} > {y}", BigInteger: "{x}.gt({y})", diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 98275ee7..0e673d24 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -203,10 +203,12 @@ def _string_builder(): @as_var("-add-to-string-builder") def _add_to_string_builder(sb, x): - from pixie.vm2.string import String + from pixie.vm2.string import String, Character if isinstance(x, String): sb.add_str(x._str) return sb + elif isinstance(x, Character): + sb.add_str(unichr(x._char_val)) else: runtime_error(u"Expected string or char", u"pixie.stdlib.IllegalArgumentException") From 9ba10e96164e459fb335a345cd2f57ec4ed40c6a Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Wed, 8 Jul 2015 06:39:40 -0600 Subject: [PATCH 33/46] fixed fn usage --- pixie/ast-output.pxi | 10 +++- pixie/bootstrap.pxi | 117 +++++++++++++++++++++++++++++++++++---- pixie/vm2/interpreter.py | 7 ++- 3 files changed, 122 insertions(+), 12 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index e6722e7e..0521a837 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -39,7 +39,6 @@ bindings)) (to-ast body) (meta-ast ast))) - ast/Do (-to-ast [{:keys [statements ret] :as ast}] (println "DO " statements ret) @@ -82,6 +81,15 @@ var-name (meta-ast ast))) + ast/FnBody + (-to-ast [{:keys [name args body] :as ast}] + (iast/->Fn (keyword (pixie.stdlib/name name)) + (to-array (map (fn [x] + (keyword (pixie.stdlib/name x))) + args)) + (to-ast body) + (meta-ast ast))) + Object (-to-ast [this] diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 5cf251d8..d00c945a 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -436,12 +436,60 @@ ([m k v & rest] (apply assoc (-assoc m k v) rest))) +(defn assoc-in + {:doc "Associate a value in a nested collection given by the path. + +Creates new maps if the keys are not present." + :examples [["(assoc-in {} [:a :b :c] 42)" nil {:a {:b {:c 42}}}]] + :added "0.1"} + ([m ks v] + (let [ks (seq ks) + k (first ks) + ks (next ks)] + (if ks + (assoc m k (assoc-in (get m k) ks v)) + (assoc m k v))))) + +(defn update-in + {:doc "Update a value in a nested collection." + :examples [["(update-in {:a {:b {:c 41}}} [:a :b :c] inc)" nil {:a {:b {:c 42}}}]] + :added "0.1"} + [m ks f & args] + (let [f (fn [m] (apply f m args)) + update-inner-f (fn update-inner-f + ([m f k] + (assoc m k (f (get m k)))) + ([m f k & ks] + (assoc m k (apply update-inner-f (get m k) f ks))))] + (apply update-inner-f m f ks))) + (defn key [m] (-key m)) (defn val [m] (-val m)) +(defn keys + {:doc "If called with no arguments returns a transducer that will extract the key from each map entry. If passed + a collection, will assume that it is a hashmap and return a vector of all keys from the collection." + :signatures [[] [coll]] + :added "0.1"} + ([] (map key)) + ([m] + (with-handler [g (->Generator)] + (transduce (map key) yield g m)))) + +(defn vals + {:doc "If called with no arguments returns a transducer that will extract the key from each map entry. If passed + a collection, will assume that it is a hashmap and return a vector of all keys from the collection." + :signatures [[] [coll]] + :added "0.1"} + ([] (map val)) + ([m] + (with-handler [g (->Generator)] + (transduce (map val) yield g m)))) + + (defn seq [x] (-seq x)) @@ -513,6 +561,20 @@ f (f acc (first s)))))) +;; Some logic functions +(defn complement + {:doc "Given a function, return a new function which takes the same arguments + but returns the opposite truth value"} + [f] + (assert (fn? f) "Complement must be passed a function") + (fn + ([] (not (f))) + ([x] (not (f x))) + ([x y] (not (f x y))) + ([x y & more] (not (apply f x y more))))) + +;; + ;; Cons and List (deftype Cons [head tail meta] @@ -721,9 +783,11 @@ (k nil)))] v))) -(defn yield [g i] - (-yield g i) - g) +(defn yield + ([g] nil) + ([g i] + (-yield g i) + g)) (defn sequence [coll] (with-handler [gen (->Generator)] @@ -949,13 +1013,8 @@ ([result] (xf result)) ([result item] (xf result (f item)))))) ([f coll] - (lazy-seq* - (fn [] - (let [s (seq coll)] - (if s - (cons (f (first s)) - (map f (next s))) - nil))))) + (with-handler [g (->Generator)] + (transduce (map f) yield g coll))) ([f & colls] (let [step (fn step [cs] (lazy-seq* @@ -971,6 +1030,22 @@ (transduce (map f) conj col))) +(defn filter + {:doc "Filter the collection for elements matching the predicate." + :signatures [[pred] [pred coll]] + :added "0.1"} + ([pred] + (fn [xf] + (fn + ([] (xf)) + ([acc] (xf acc)) + ([acc i] (if (pred i) + (xf acc i) + acc))))) + ([pred coll] + (with-handler [g (->Generator)] + (transduce (filter pred) yield g coll)))) + (defn interpose ^{:doc "Returns a transducer that inserts `val` in between elements of a collection." :signatures [[val] [val coll]] @@ -1021,6 +1096,18 @@ ([f coll] (transduce (mapcat f) conj coll))) +(defn every? + {:doc "Check if every element of the collection satisfies the predicate." + :added "0.1"} + [pred coll] + (reduce + (fn [_ i] + (if (pred i) + true + (reduced false))) + true + coll)) + ;; End Basic Transudcer Support @@ -1256,6 +1343,16 @@ (array-copy arr 0 new-array 0 size) new-array)) +(defn to-array [coll] + (let [arr (make-array (count coll))] + (reduce + (fn [idx i] + (aset arr idx i) + (inc idx)) + 0 + coll) + arr)) + ;;; ;; Atom diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 8b55a385..9a453665 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -140,12 +140,17 @@ def interpret(self, _, locals, stack): def gather_locals(self): return {self._c_name: self._c_name} -as_var("pixie.ast.internal", "->Fn") +@as_var("pixie.ast.internal", "->Fn") def new_fn(name, args, body, meta): return Fn(name, args.array_val(), body, meta) class Fn(AST): _immutable_fields_ = ["_c_name", "_c_args", "_c_body", "_c_closed_overs"] + + _type = Type(u"pixie.ast.internal.Fn") + def type(self): + return Fn._type + def __init__(self, name, args, body, closed_overs=[], meta=nil): AST.__init__(self, meta) self._c_name = name From b3593ddb5311fab5e62c932117a7e883bb64b78f Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 13 Jul 2015 16:54:24 -0600 Subject: [PATCH 34/46] dynamic var support, fixes for the reader --- pixie/ast-output.pxi | 6 ++ pixie/bootstrap-macros.pxi | 15 +++++ pixie/bootstrap.pxi | 113 +++++++++++++++++++++++++++++-------- pixie/compiler.pxi | 10 +++- pixie/pxic-writer.pxi | 12 ++-- pixie/reader.pxi | 31 ++++++---- pixie/stdlib.pxi | 23 -------- pixie/vm2/interpreter.py | 58 +++++++++++++++++-- pixie/vm2/pxic_reader.py | 5 +- pixie/vm2/stdlib.py | 16 +++++- 10 files changed, 214 insertions(+), 75 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index 0521a837..30405e34 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -81,6 +81,12 @@ var-name (meta-ast ast))) + ast/VarConst + (-to-ast [{:keys [ns name env] :as ast}] + (iast/->VarConst ns + name + (meta-ast ast))) + ast/FnBody (-to-ast [{:keys [name args body] :as ast}] (iast/->Fn (keyword (pixie.stdlib/name name)) diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index b7a8c480..f91a9fa0 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -152,4 +152,19 @@ and implements IAssociative, ILookup and IObject." (let [~bind tmp#] ~@body))))) +(defmacro set! [v val] + `(-dynamic-var-set dynamic-var-handler (var ~v) ~val)) + +(defmacro binding [bindings & body] + (let [parted (partition 2 bindings)] + `(let [vars# (-dynamic-get-vars dynamic-var-handler)] + (with-handler [_# dynamic-var-handler] + (-dynamic-set-vars dynamic-var-handler + (assoc vars# + ~@(mapcat + (fn [[var-name binding]] + [`(var ~var-name) + binding]) + parted))) + ~@body)))) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index d00c945a..424a582d 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -1353,6 +1353,21 @@ Creates new maps if the keys are not present." coll) arr)) +;;; Extend Var + +(extend-type Var + IObject + (-str [this sb] + (if (namespace this) + (do (sb "")) + (do (sb ""))))) + ;;; ;; Atom @@ -2091,9 +2106,9 @@ Creates new maps if the keys are not present." IObject (-hash [this] (when-not hash-val - (set! this :hash-val (reduce - unordered-hashing-rf - this))) + (set-field! this :hash-val (reduce + unordered-hashing-rf + this))) hash-val) (-str [this sb] @@ -2349,9 +2364,11 @@ user => (refer 'pixie.string :exclude '(substring))" ;; Dynamic Vars -(defeffect EDynamicVar - (-dynamic-var-lookup [this]) - (-dynamic-var-set [this val])) +(defeffect EDynamicVarEnv + (-dynamic-var-get [this var]) + (-dynamic-var-set [this var val]) + (-dynamic-get-vars [this]) + (-dynamic-set-vars [this s'])) (deftype DynamicVar [x] IEffect @@ -2363,33 +2380,36 @@ user => (refer 'pixie.string :exclude '(substring))" (println "Effect Return " f) (f x)) - EDynamicVar - (-dynamic-var-lookup [this k] + EDynamicVarEnv + (-dynamic-var-get [this var k] (println "lookup") (fn lookup-fn [s] (println "lookup -> " s k) - ((k s) s))) + ((k (get s var)) s))) - (-dynamic-var-set [this s' k] - (println "call set " s' k) + (-dynamic-var-set [this var val k] + (println "call set " var val) (fn [s] - (println "Setting to | " s' s) - ((k nil) s'))) + (println "Setting to | " var val) + ((k nil) (assoc s var val)))) + + (-dynamic-get-vars [this k] + (println "get vars" this k) + (fn [s] + (println "getting vars " s) + ((k s) s))) + + (-dynamic-set-vars [this s' k] + (println "set vars" this s') + (fn set-vars [s] + ((k nil) s')))) + + +(def dynamic-var-handler (->DynamicVar {})) - IDeref - (-deref [this] - (-dynamic-var-lookup this)) - IReset - (-reset! [this v] - (-dynamic-var-set this v))) -(defn dynamic-var - ([] - (dynamic-var nil)) - ([v] - (->DynamicVar v))) ;; @@ -2528,3 +2548,48 @@ The params can be destructuring bindings, see `(doc let)` for details."} (if (= (count decls) 1) `(fn* ~@name ~(first (first decls)) ~@(next (first decls))) `(fn* ~@name ~@decls)))) + + +;; State + +(defeffect EState + (-state-lookup [this k]) + (-state-update [this key f args])) + +(deftype State [x] + IEffect + (-effect-val [this y] + (fn val-fn [s] y)) + + (-effect-finally [this f] + (f x)) + + EState + (-state-lookup [this key k] + (fn lookup-fn [s] + ((k (get s key)) s))) + + (-state-update [this key f args k] + (fn [s] + (let [new-state (assoc s key (apply f (get s key) args))] + ((k nil) new-state)))) + + + ILookup + (-val-at [this k] + (-sate-lookup this k))) + +(defn state + ([] + (state {})) + ([s] + (->State s))) + +(defn update [s k f & args] + (-state-update s k v)) + +(defmacro with-state [[n] & body] + `(with-handler [~n (state)] + ~@body)) + + diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 0fb055d0..2739304f 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -43,7 +43,7 @@ (defmethod analyze-seq 'comment [env x] - (->Const x env)) + (->Const nil env)) (defmethod analyze-seq 'if [env [_ test then else :as form]] @@ -204,7 +204,8 @@ (defmethod analyze-seq 'quote [env [_ val]] (if (map? val) - (analyze-seq (with-meta + (analyze-seq env + (with-meta `(pixie.stdlib/hashmap ~@(reduce (fn [acc [k v]] (-> acc @@ -346,7 +347,10 @@ (meta x)))) (defn maybe-var [env x] - (->Var @(:ns env) x x env)) + (let [nsp (if (= (namespace x) "pixie.bootstrap-macros") + (symbol (str "pixie.stdlib/" (name x))) + x)] + (->Var @(:ns env) nsp nsp env))) ;; ENV Functions diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index 2ac521f0..db91d02d 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -205,13 +205,11 @@ ast/VarConst - (-write-object [{:keys [ns name]} os] - (write-cached-obj *cache* - [:const ns name] - (fn [_ ns name] - (write-tag os VAR-CONST) - (write-raw-string os (str ns)) - (write-raw-string os (str name))))) + (-write-object [{:keys [ns name] :as ast} os] + (write-tag os VAR-CONST) + (write-raw-string os (str ns)) + (write-object os name) + (write-meta os ast)) ast/Var (-write-object [{:keys [ns var-name] :as ast} os] diff --git a/pixie/reader.pxi b/pixie/reader.pxi index 74660f67..9f8f8cee 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -1,6 +1,9 @@ (ns pixie.reader (:require [pixie.string :as string])) +(def *current-ns* nil) +(set-dynamic! (var *current-ns*)) + (defprotocol IPushbackReader (read-ch [this]) @@ -127,12 +130,12 @@ (str "Unmatched delimiter " unhandled-ch)]))) -(def *gen-sym-env* (dynamic-var)) +(def *gen-sym-env* nil) +(set-dynamic! (var *gen-sym-env*)) (defn syntax-quote-reader [rdr] (let [form (read-inner rdr true)] - (with-handler [*gen-sym-env* *gen-sym-env*] - (reset! *gen-sym-env* {}) + (binding [*gen-sym-env* {}] (syntax-quote form)))) (defn unquote? [form] @@ -151,15 +154,21 @@ (list 'quote form) (symbol? form) - (if (not (namespace form) - (string/ends-with (name form) "#")) - (let [gmap @*gen-sym-env* + (cond + (namespace form) + (list 'quote form) + + (string/ends-with? (name form) "#") + (let [gmap *gen-sym-env* _ (assert gmap "Gensym literal used outside of a syntax quote") gs (or (get gmap form) - (let [s (symbol (gensym (str (name form) "__")))] - (reset! *gen-sym-env* (assoc gmap form s))))] + (let [s (gensym (str (name form) "__"))] + (set! *gen-sym-env* (assoc gmap form s)) + s))] (list 'quote gs)) - (list '-resolve-in form)) + + :else + (list 'quote (symbol (str (name *current-ns*) "/" (name form))))) (unquote? form) (first (next form)) @@ -171,7 +180,7 @@ (list 'pixie.stdlib/apply 'pixie.apply/concat (expand-list form)) (and form (seq? form)) - (list 'pixie.stdlib/apply 'pixie.apply/list (expand-list form)) + (list 'pixie.stdlib/apply 'pixie.stdlib/list (expand-list form)) :else (list 'quote form))) @@ -185,7 +194,7 @@ (unquote-splicing? form) (conj acc (nth form 1)) - :else (conj acc [(syntax-quote form)]))) + :else (conj acc (syntax-quote itm)))) [] form)) diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index da8bf380..39bcbc3e 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -1136,17 +1136,6 @@ Creates new maps if the keys are not present." [sym] `(resolve-in (this-ns-name) ~sym)) -(defmacro binding [bindings & body] - (let [bindings (apply hashmap bindings) - set-vars (reduce (fn [res binding] - (conj res `(set! (resolve (quote ~(key binding))) ~(val binding)))) - [] - bindings)] - `(do (push-binding-frame!) - ~@set-vars - (let [ret (do ~@body)] - (pop-binding-frame!) - ret)))) (defmacro ns [nm & body] (let [bmap (reduce (fn [m b] @@ -1440,19 +1429,7 @@ The new value is thus `(apply f current-value-of-atom args)`." ([x y & more] `(let [r# ~x] (if r# r# (or ~y ~@more))))) -(defmacro when [test & body] - `(if ~test (do ~@body))) -(defmacro when-not [test & body] - `(if (not ~test) (do ~@body))) - -(defmacro when-let [binding & body] - (let [bind (nth binding 0 nil) - test (nth binding 1 nil)] - `(let [tmp# ~test] - (when tmp# - (let [~bind tmp#] - ~@body))))) (defmacro if-not ([test then] `(if-not ~test ~then nil)) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 9a453665..22b54c2f 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -100,6 +100,7 @@ def interpret(self, _, locals, stack): def gather_locals(self): return {} + @expose("_c_value", "_c_name", "_c_next") class Locals(object): _immutable_ = True @@ -146,7 +147,7 @@ def new_fn(name, args, body, meta): class Fn(AST): _immutable_fields_ = ["_c_name", "_c_args", "_c_body", "_c_closed_overs"] - + _type = Type(u"pixie.ast.internal.Fn") def type(self): return Fn._type @@ -481,6 +482,9 @@ def get_ast(self): def new_vderef(in_ns, var_name, meta): return VDeref(in_ns.get_name(), var_name, meta) +dynamic_var_get = code.intern_var(u"pixie.stdlib", u"-dynamic-var-get") +dynamic_var_handler = code.intern_var(u"pixie.stdlib", u"dynamic-var-handler") + @expose("_c_var") class VDeref(AST): _immutable_fields_ = ["_c_in_ns", "_c_var_name"] @@ -498,7 +502,10 @@ def interpret(self, val, locals, stack): var = ns.resolve_in_ns_ex(self._c_var_ns, self._c_var_name) if var is not None: - return var.deref(), stack + if var.is_dynamic(): + return dynamic_var_get.invoke_k([dynamic_var_handler.deref(), var], stack) + else: + return var.deref(), stack else: runtime_error(u"Var " + (self._c_var_ns + u"/" if self._c_var_ns else u"") @@ -511,6 +518,50 @@ def gather_locals(self): return {} +@as_var("pixie.ast.internal", "->VarConst") +def new_vderef(in_ns, var_name, meta): + return VarConst(in_ns.get_name(), var_name, meta) + +@expose("_c_var") +class VarConst(AST): + _immutable_fields_ = ["_c_in_ns", "_c_var_name"] + _type = Type(u"pixie.ast.internal.VarConst") + + def type(self): + return VarConst._type + + def __init__(self, in_ns, var_name, meta=nil): + AST.__init__(self, meta) + self._c_in_ns = in_ns + self._c_var_ns = None if var_name.get_ns() == u"" else var_name.get_ns() + self._c_var_name = var_name.get_name() + + def interpret(self, val, locals, stack): + ns = ns_registry.find_or_make(self._c_in_ns) + if ns is None: + runtime_error(u"Namespace " + self._c_in_ns + u" is not found", + u"pixie.stdlib/UndefinedNamespace") + + var = ns.resolve_in_ns_ex(self._c_var_ns, self._c_var_name) + if var is not None: + return var, stack + else: + if self._c_var_ns is not None: + runtime_error(u"Var " + + (self._c_var_ns + u"/" if self._c_var_ns else u"") + + self._c_var_name + + u" is undefined in " + + self._c_in_ns, + u"pixie.stdlib/UndefinedVar") + else: + return ns.intern_or_make(self._c_var_name), stack + + + def gather_locals(self): + return {} + + + from rpython.rlib.jit import JitDriver from rpython.rlib.objectmodel import we_are_translated def get_printable_location(ast): @@ -653,8 +704,7 @@ def slice_stack(self, orig_stack, handler): while True: if stack is None: ## No hander found - size = -1 - break + runtime_error(u"No handler found") if isinstance(stack._cont, Handler) and stack._cont.handler() is handler: size += 1 diff --git a/pixie/vm2/pxic_reader.py b/pixie/vm2/pxic_reader.py index 499e78c2..b9aa228e 100644 --- a/pixie/vm2/pxic_reader.py +++ b/pixie/vm2/pxic_reader.py @@ -143,8 +143,9 @@ def read_object(os): elif tag == VAR_CONST: ns = read_raw_string(os) - name = read_raw_string(os) - return ast.Const(code.intern_var(ns, name), nil) + name = read_object(os) + meta = read_object(os) + return ast.VarConst(ns, name, meta) elif tag == CONST: return ast.Const(read_object(os)) diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 0e673d24..13a95fcd 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -387,4 +387,18 @@ def macro_QMARK_(f): @extend_var("pixie.stdlib", "-deref", Var) def __deref(self): assert isinstance(self, Var) - return self.deref() \ No newline at end of file + return self.deref() + + +@extend_var("pixie.stdlib", "-name", Var) +def __deref(self): + assert isinstance(self, Var) + return rt.wrap(self._name) + + +@extend_var("pixie.stdlib", "-namespace", Var) +def __deref(self): + assert isinstance(self, Var) + return rt.wrap(self._ns) + + From 89aecaaa5371e46b90229c1e3113ec509180b915 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 13 Jul 2015 16:54:52 -0600 Subject: [PATCH 35/46] forgot to add main.pxi --- pixie/main.pxi | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 pixie/main.pxi diff --git a/pixie/main.pxi b/pixie/main.pxi new file mode 100644 index 00000000..7a37c78b --- /dev/null +++ b/pixie/main.pxi @@ -0,0 +1,38 @@ +(ns pixie.main + (:require [pixie.io-blocking :as io] + [pixie.reader :as reader] + [pixie.compiler :as compiler] + [pixie.ast-output :as ast-out])) + +(def libedit (ffi-library "libedit.dylib")) +(println libedit) +(def -readline (ffi-fn libedit "readline" [CCharP] CCharP)) + +(defrecord Foo [x y]) + +(let [env (compiler/new-env false) + _ (println "MAKE ENV " (:ns env)) + data (reader/read-string "( * 1 2)") + _ (println "got " data) + ast (ast-out/to-ast (compiler/analyze data env))] + (println "_> ast -> " ast) + (println (pixie.ast.internal/eval ast))) + +(defn repl [] + (with-handler [_ dynamic-var-handler] + (binding [reader/*current-ns* 'user] + (let [read-fn #(str (-readline "=>") "\n") + rdr (reader/metadata-reader + (reader/user-space-reader read-fn) + "")] + (loop [] + (let [d (reader/read rdr false)] + (println "got " d) + (println "analyzing ") + (let [analyzed (ast-out/to-ast (compiler/analyze d))] + (println "analyzed " analyzed) + (println "result :" (pixie.ast.internal/eval analyzed))) + (recur))))))) +(repl) + +(println "done") From 101371f6eb49f68abde6594b48347f1dfff39b30 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 14 Jul 2015 17:09:43 -0600 Subject: [PATCH 36/46] implement load-file, keyword support in the reader, bug fixes --- pixie/ast-output.pxi | 4 ++++ pixie/bootstrap-macros.pxi | 38 +++++++++++++++++++++++++++++++++++++- pixie/bootstrap.pxi | 19 +++++++++++++++++++ pixie/compiler.pxi | 2 +- pixie/main.pxi | 38 +++++++++++++++++++++++++++++++++++++- pixie/reader.pxi | 12 ++++++++++++ pixie/vm/string.py | 1 + pixie/vm2/rt.py | 1 + pixie/vm2/stdlib.py | 32 -------------------------------- pixie/vm2/string.py | 8 ++++++++ 10 files changed, 120 insertions(+), 35 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index 30405e34..84edb33a 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -96,6 +96,10 @@ (to-ast body) (meta-ast ast))) + ast/Binding + (-to-ast [{:keys [name] :as ast}] + (iast/->Lookup (keyword (pixie.stdlib/name name)) + (meta-ast ast))) Object (-to-ast [this] diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index f91a9fa0..1c18670d 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -64,7 +64,7 @@ (defmacro ns [nm & body] (let [bmap (reduce (fn [m b] - (update-in m [(first b)] (fnil conj []) (rest b))) + (update-in m [(first b)] (fnil conj []) (next b))) {} body) requires @@ -168,3 +168,39 @@ and implements IAssociative, ILookup and IObject." parted))) ~@body)))) + +(defmacro fn + {:doc "Creates a function. + +The following two forms are allowed: + (fn name? [param*] & body) + (fn name? ([param*] & body)+) + +The params can be destructuring bindings, see `(doc let)` for details."} + [& decls] + (let [name (if (symbol? (first decls)) [(first decls)] nil) + decls (if name (next decls) decls) + decls (cond + (vector? (first decls)) (list decls) + ;(satisfies? ISeqable (first decls)) decls + ;:else (throw (str "expected a vector or a seq, got a " (type decls))) + :else decls) + decls (seq (map (fn* [decl] + (let [argv (first decl) + names (vec (map #(if (= % '&) '& (gensym "arg__")) argv)) + bindings (loop [i 0 bindings []] + (if (< i (count argv)) + (if (= (nth argv i) '&) + (recur (inc i) bindings) + (recur (inc i) (reduce conj bindings [(nth argv i) (nth names i)]))) + bindings)) + body (next decl)] + (if (every? symbol? argv) + `(~argv ~@body) + `(~names + (let ~bindings + ~@body))))) + decls))] + (if (= (count decls) 1) + `(fn* ~@name ~(first (first decls)) ~@(next (first decls))) + `(fn* ~@name ~@decls)))) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 424a582d..c38f35c5 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -536,6 +536,11 @@ Creates new maps if the keys are not present." (array-copy args 0 arg-array 0 but-last-cnt) (-apply f arg-array))) +(defn fnil [f else] + (fn [x & args] + (apply f (if (nil? x) else x) args))) + + (defn last [coll] (if (vector? coll) (nth coll (dec (count coll))) @@ -2267,6 +2272,14 @@ Creates new maps if the keys are not present." (-deref [this] nil) + IIndexed + + (-nth [this idx] + (throw [:pixie.stdlib/IndexOutOfRangeException + "Index out of range"])) + (-nth-not-found [this idx not-found] + not-found) + IReduce (-reduce [this f init] init) @@ -2346,6 +2359,12 @@ user => (refer 'pixie.string :exclude '(substring))" nil)) +(defn load-ns [ns-sym] + (assert (not (namespace ns-sym)) "Namespace names must not be namespaced") + (println "LOADING " ns-sym) + (or (the-ns ns-sym) + (load-file ns-sym))) + ;; End NS Functions ;; Delay diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 2739304f..b315ab0c 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -7,6 +7,7 @@ (cond (identical? x true) :bool (identical? x false) :bool + (keyword? x) :keyword (nil? x) nil (seq? x) :seq (vector? x) :vector @@ -14,7 +15,6 @@ (number? x) :number (string? x) :string (char? x) :char - (keyword? x) :keyword (map? x) :map (set? x) :set :else (do (println "Cant' Analyze " x) diff --git a/pixie/main.pxi b/pixie/main.pxi index 7a37c78b..1ef708bd 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -2,7 +2,43 @@ (:require [pixie.io-blocking :as io] [pixie.reader :as reader] [pixie.compiler :as compiler] - [pixie.ast-output :as ast-out])) + [pixie.ast-output :as ast-out] + [pixie.string :as string])) + +(defn load-file [ns-sym] + (let [name (if (string? ns-sym) + ns-sym + (string/replace (name ns-sym) "." "/")) + name (if (string/ends-with? name ".pxi") + name + (str name ".pxi")) + full-name (reduce + (fn [_ load-path] + (let [nm (str load-path "/" name)] + (println "Looking for " nm) + (when (pixie.io-blocking/file-exists? nm) + (reduced nm)))) + nil + @load-paths)] + (assert full-name (str "Couldn't load file " ns-sym)) + (load-resolved-file full-name))) + +(defn load-resolved-file [full-name] + (let [data (io/slurp full-name) + rdr (reader/metadata-reader + (reader/indexed-reader data) + full-name)] + (with-handler [_ dynamic-var-handler] + (binding [reader/*current-ns* 'user] + (loop [] + (let [d (reader/read rdr false) + analyzed (ast-out/to-ast (compiler/analyze d))] + (println "GOT " d) + (pixie.ast.internal/eval analyzed) + (recur))))))) + +#_(load-file :pixie.ffi-infer) + (def libedit (ffi-library "libedit.dylib")) (println libedit) diff --git a/pixie/reader.pxi b/pixie/reader.pxi index 9f8f8cee..214f1405 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -23,6 +23,9 @@ (unread-ch [this] (set-field! this :idx (dec idx)))) +(defn indexed-reader [s] + (->IndexedReader s 0)) + (deftype UserSpaceReader [string-rdr reader-fn] IPushbackReader (read-ch [this] @@ -259,6 +262,14 @@ :else (do (sb-fn ch) (recur))))))) +(defn keyword-reader [rdr] + (let [ch (read-ch rdr)] + (assert (not= \: ch)) + (let [itm (read-symbol rdr ch)] + (if (namespace itm) + (keyword (str (namespace itm) "/" (name itm))) + (keyword (name itm)))))) + (def handlers (switch-table \( (make-coll-reader list \( \)) @@ -267,6 +278,7 @@ \] (make-unmatched-handler \]) \) (make-unmatched-handler \)) \} (make-unmatched-handler \}) + \: keyword-reader \` syntax-quote-reader \@ deref-reader \; skip-line-reader diff --git a/pixie/vm/string.py b/pixie/vm/string.py index c9be8844..a8358d04 100644 --- a/pixie/vm/string.py +++ b/pixie/vm/string.py @@ -152,3 +152,4 @@ def _namespace(self): def _hash(self): assert isinstance(self, String) return rt.wrap(intmask(util.hash_unencoded_chars(self._str))) + diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index aaec77d8..df649dde 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -50,6 +50,7 @@ def wrapper(*args): import pixie.vm2.code as code import pixie.vm2.numbers as numbers + import pixie.vm2.files import pixie.vm2.stdlib import pixie.vm2.array import pixie.vm2.custom_types diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index 13a95fcd..d9456a3c 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -233,38 +233,6 @@ def the_ns(ns_name): return code.ns_registry.get(ns_name.get_name(), nil) -@as_var("load-ns") -def load_ns(filename): - import pixie.vm2.string as string - import pixie.vm2.symbol as symbol - import os.path as path - - if isinstance(filename, symbol.Symbol): - affirm(filename.get_ns() is None, u"load-file takes a un-namespaced symbol") - filename_str = filename.get_name().replace(u".", u"/") + u".pxi" - - loaded_ns = code.ns_registry.get(filename.get_name(), None) - if loaded_ns is not None: - return loaded_ns - else: - affirm(isinstance(filename, string.String), u"Filename must be string") - filename_str = filename.get_name - - # paths = rt.deref(rt.deref(rt.load_paths)) - # f = None - # for x in range(rt.count(paths)): - # path_x = rt.nth(paths, rt.wrap(x)) - # affirm(isinstance(path_x, string.String), u"Contents of load-paths must be strings") - # full_path = path.join(str(rt.name(path_x)), str(filename_str)) - # if path.isfile(full_path): - # f = full_path - # break - # - # if f is None: - # affirm(False, u"File '" + rt.name(filename) + u"' does not exist in any directory found in load-paths") - # else: - # rt.load_file(rt.wrap(f)) - return nil ### NS Helpers diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index fad30796..efec4a6f 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -230,3 +230,11 @@ def startswith(a, b): @as_var("pixie.string", "ends-with?") def endswith(a, b): return rt.wrap(a.get_name().endswith(b.get_name())) + + +@as_var("pixie.string", "replace") +def str_replace(s, sfrom, sto): + affirm(isinstance(s, String), u"Expected string") + affirm(isinstance(sfrom, String), u"Expected string") + affirm(isinstance(sto, String), u"Expected string") + return rt.wrap(s.get_name().replace(sfrom.get_name(), sto.get_name())) \ No newline at end of file From ef66edf6b883f1911f50230e726da4966cca9063 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Wed, 15 Jul 2015 22:41:59 -0600 Subject: [PATCH 37/46] bunch of compiler fixes, got try/catch debugged a bit --- pixie/ast.pxi | 8 +------ pixie/bootstrap-macros.pxi | 13 +++++++++++ pixie/bootstrap.pxi | 20 +++++++++++++++-- pixie/compiler.pxi | 44 ++++++++++++++++++++++++-------------- pixie/main.pxi | 6 +++++- pixie/vm2/code.py | 8 +++++++ pixie/vm2/interpreter.py | 41 +++++++++++++++++++++++++++-------- pixie/vm2/stdlib.py | 2 ++ 8 files changed, 107 insertions(+), 35 deletions(-) diff --git a/pixie/ast.pxi b/pixie/ast.pxi index 32f25a53..38df82bc 100644 --- a/pixie/ast.pxi +++ b/pixie/ast.pxi @@ -93,7 +93,7 @@ (defn make-var-const-ast [ns name env] - (->VarConst ns name (symbol (pixie.stdlib/name name)) env)) + (->VarConst ns (symbol (pixie.stdlib/name name)) name env)) (defn make-invoke-var-ast [ns name args form env] (make-invoke-ast @@ -154,12 +154,6 @@ Vector (simplify-ast [{:keys [items form env]}] - (if (not (:bootstrap? env)) - (println "Vector > " items - (seq items) - (count (seq items)) - (first (seq items)) - (first (next (seq items))))) (make-invoke-var-ast "pixie.stdlib" (if (:bootstrap? env) diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index 1c18670d..13908917 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -204,3 +204,16 @@ The params can be destructuring bindings, see `(doc let)` for details."} (if (= (count decls) 1) `(fn* ~@name ~(first (first decls)) ~@(next (first decls))) `(fn* ~@name ~@decls)))) + + +(defmacro assert + ([test] + `(if ~test + nil + (throw [:pixie.stdlib/AssertionException + "Assert failed"]))) + ([test msg] + `(if ~test + nil + (throw [:pixie.stdlib/AssertionException + (str "Assert failed: " ~msg)])))) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index c38f35c5..a851c2a7 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -114,10 +114,12 @@ EException (-throw [this kw data ks k] - (let [c (get catches kw)] + (let [c (or (get catches kw) + (get catches :*))] + (println "Got Exception" kw c) (if c (c data) - (-throw this kw data (conj ks k)))))) + (-throw nil kw data (conj ks k)))))) (defn throw [kw val] (-throw nil @@ -2263,6 +2265,20 @@ Creates new maps if the keys are not present." (-eq [this other] (identical? this other)) + IPersistentCollection + (-conj [this x] + (vector x)) + (-disj [this x] + nil) + + IAssociative + (-assoc [this k v] + (hashmap k v)) + (-dissoc [this k] + nil) + (-contains-key [this k] + false) + ILookup (-val-at ([this k] nil) diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index b315ab0c..e41a42c4 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -3,6 +3,11 @@ [pixie.ast :refer :all])) +(defn remove-bootstrap [env sym] + (if (= (namespace x) "pixie.bootstrap-macros") + (symbol (str "pixie.stdlib/" (name x))) + x)) + (defmulti analyze-form (fn [_ x] (cond (identical? x true) :bool @@ -109,7 +114,7 @@ (let [[_ k ex-nm & body] f] (assert (keyword? k) "First argument to catch must be a keyword") (assoc-in acc [:catches k] `(fn [~ex-nm] - ~body))) + ~@body))) (and (seq? f) (= (first f) 'finally)) (let [[_ & body] f] @@ -250,22 +255,34 @@ new) new)) +(defn resolve-sym [env sym] + (cond + (and (:bootstrap? env)) + (try (resolve-in (the-ns :pixie.bootstrap-macros) + (symbol (name sym))) + (catch :pixie.stdlib/AssertionException ex + nil)) + + (namespace sym) + (try (resolve-in (the-ns (namespace sym)) + (symbol (name sym))) + (catch :pixie.stdlib/AssertionException ex + nil)) + + :else + (try (resolve-in (the-ns @(:ns env)) + sym) + (catch :pixie.stdlib/AssertionException ex + nil)))) + (defmethod analyze-seq :default [env [sym & args :as form]] (let [sym (if (and (symbol? sym) (= "pixie.bootstrap-macros" (namespace sym))) (symbol (str "pixie.stdlib/" (name sym))) sym) - bootstrap-resolved (when (and (symbol? sym) - (:bootstrap? env)) - (try (and (symbol? sym) - (resolve-in (the-ns :pixie.bootstrap-macros) (symbol (name sym)))) - (catch :pixie.stdlib/AssertionException ex - nil))) - resolved (try (and (symbol? sym) - (resolve-in (the-ns @(:ns env)) sym)) - (catch :pixie.stdlib/AssertionException ex - nil))] + resolved (when (symbol? sym) + (resolve-sym env sym))] (cond (and (symbol? sym) (string/starts-with? (name sym) ".-")) @@ -274,11 +291,6 @@ form))] result) - (and bootstrap-resolved - (macro? @bootstrap-resolved)) - (analyze-form env (keep-meta (apply @bootstrap-resolved args) - form)) - (and resolved (macro? @resolved)) (analyze-form env (keep-meta (apply @resolved args) diff --git a/pixie/main.pxi b/pixie/main.pxi index 1ef708bd..71690463 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -32,12 +32,16 @@ (binding [reader/*current-ns* 'user] (loop [] (let [d (reader/read rdr false) + _ (println "Compiling " d) analyzed (ast-out/to-ast (compiler/analyze d))] (println "GOT " d) (pixie.ast.internal/eval analyzed) (recur))))))) -#_(load-file :pixie.ffi-infer) +(try + (load-file :pixie.ffi-infer) + (catch :* ex + (println "ERROR Compiling file"))) (def libedit (ffi-library "libedit.dylib")) diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index a6313980..daa463e2 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -767,6 +767,14 @@ def extend(self, tp, fn): self._fn_cache = {} self._protocol.add_satisfies(tp) + def satisfied_by(self, o): + if not isinstance(o, object.Type): + o = o.type() + + print "SATISFY", o, self._name, o._name, self._protocol._name + return self._protocol.satisfies(o) + + def _find_parent_fn(self, tp): ## Search the entire object tree to find the function to execute assert isinstance(tp, object.Type) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 22b54c2f..9e74605b 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -3,7 +3,7 @@ from pixie.vm2.primitives import nil, false from pixie.vm2.array import Array import pixie.vm2.code as code -from pixie.vm2.keyword import Keyword +from pixie.vm2.keyword import Keyword, keyword from pixie.vm2.code import BaseCode import rpython.rlib.jit as jit @@ -121,7 +121,7 @@ def get_local(self, name): while c._c_name is not name: c = c._c_next if c is None: - runtime_error(name.to_repr() + u" is undefined") + runtime_error(u"Local" + name.to_repr() + u" is undefined") return c._c_value @as_var("pixie.ast.internal", "->Lookup") @@ -163,6 +163,9 @@ def __init__(self, name, args, body, closed_overs=[], meta=nil): if x in glocals: del glocals[x] + if self._c_name in glocals: + del glocals[self._c_name] + closed_overs = [None] * len(glocals) idx = 0 @@ -569,6 +572,8 @@ def get_printable_location(ast): jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) +throw_var = code.intern_var(u"pixie.stdlib", u"throw") + def run_stack(val, cont, stack=None, enter_debug=True): stack = None val = None @@ -582,11 +587,12 @@ def run_stack(val, cont, stack=None, enter_debug=True): if enter_debug: from pixie.vm2.debugger import debug #debug(cont, stack, val) - print_stacktrace(cont, stack) + #print_stacktrace(cont, stack) if not we_are_translated(): print ex - raise - break + + val, stack = throw_var.invoke_k([keyword(u"pixie.stdlib/InternalException"), + keyword(u"TODO")], stack) if stack: cont = stack._cont @@ -679,9 +685,16 @@ def invoke_k(self, args, stack): affirm(len(args) >= 1, u"Effect functions require at least one argument") handler = args[0] - stack, slice = self.slice_stack(stack, handler) + stack, slice, handler = self.slice_stack(stack, handler) + + new_args = [None] * (len(args) + 1) + + # Patch in the handler because the original handler may be nil + new_args[0] = handler + for x in range(1, len(args)): + new_args[x] = args[x] + new_args[len(args)] = DelimitedContinuation(slice) - new_args = self.append_args(args, DelimitedContinuation(slice)) return self._inner_fn.invoke_k(new_args, stack) @@ -698,16 +711,26 @@ def append_args(self, args, val): @jit.unroll_safe def slice_stack(self, orig_stack, handler): + if handler is nil: + affirm(isinstance(self._inner_fn, code.PolymorphicFn), u"Can't dispatch with a nil handler from a non polymorphic effect") size = 0 stack = orig_stack + ret_handler = None + while True: if stack is None: ## No hander found + if not we_are_translated(): + print "Looking for handler, none found, ", handler runtime_error(u"No handler found") - if isinstance(stack._cont, Handler) and stack._cont.handler() is handler: + + print "Check: ", stack._cont, size, handler, handler.type()._name + if (isinstance(stack._cont, Handler) and stack._cont.handler() is handler) or \ + (handler is nil and isinstance(stack._cont, Handler) and self._inner_fn.satisfied_by(stack._cont.handler())): size += 1 + ret_handler = stack._cont.handler() break size += 1 @@ -720,7 +743,7 @@ def slice_stack(self, orig_stack, handler): slice[x] = stack._cont stack = stack._parent - return stack, slice + return stack, slice, ret_handler def merge_dicts(a, b): diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index d9456a3c..fd54ee54 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -293,6 +293,8 @@ def set_dynamic(var): @as_var("resolve-in") def _var(ns, nm): + if ns is nil: + return nil if not isinstance(ns, code.Namespace): ns = code.ns_registry.find_or_make(ns.get_name()) From 8850896b888d119f521aab2a7465216d782a5a16 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Thu, 16 Jul 2015 22:18:21 -0600 Subject: [PATCH 38/46] more debug fixes, getting through ffi-infer --- pixie/ast.pxi | 1 + pixie/bootstrap.pxi | 118 ++++++++++++++++++++++++++++++++++++++- pixie/main.pxi | 33 ++++++++++- pixie/reader.pxi | 2 +- pixie/vm2/arraymap.py | 35 ++++++++++++ pixie/vm2/code.py | 1 - pixie/vm2/interpreter.py | 76 ++++++++++++++++++++++++- pixie/vm2/rt.py | 1 + 8 files changed, 259 insertions(+), 8 deletions(-) create mode 100644 pixie/vm2/arraymap.py diff --git a/pixie/ast.pxi b/pixie/ast.pxi index 38df82bc..5ff3853a 100644 --- a/pixie/ast.pxi +++ b/pixie/ast.pxi @@ -163,6 +163,7 @@ form env)) + Def (simplify-ast [{:keys [name env value form]}] (make-invoke-var-ast diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index a851c2a7..9f29ba0a 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -118,8 +118,8 @@ (get catches :*))] (println "Got Exception" kw c) (if c - (c data) - (-throw nil kw data (conj ks k)))))) + (c {:ex kw :data data :ks (conj ks k)}) + (-throw nil kw data (cons k ks)))))) (defn throw [kw val] (-throw nil @@ -296,6 +296,10 @@ [x] (identical? x nil)) +(defn deref + [x] + (-deref x)) + (defn conj {:doc "Adds elements to the transient collection. Elements are added to the end except in the case of Cons lists" :signatures [[] [coll] [coll item] [coll item & args]] @@ -438,6 +442,17 @@ ([m k v & rest] (apply assoc (-assoc m k v) rest))) +(defn merge + ([a] a) + ([a b] + (reduce + (fn [a [k v]] + (assoc a k v)) + a + b)) + ([a b & cs] + (apply merge (merge a b) cs))) + (defn assoc-in {:doc "Associate a value in a nested collection given by the path. @@ -559,6 +574,44 @@ Creates new maps if the keys are not present." (next coll)) (seq res)))) +(defn ith + {:doc "Returns the ith element of the collection, negative values count from the end. + If an index is out of bounds, will throw an Index out of Range exception. + However, if you specify a not-found parameter, it will substitute that instead" + :signatures [[coll i] [coll idx not-found]] + :added "0.1"} + ([coll i] + (when coll + (let [idx (if (neg? i) (+ i (count coll)) i)] + (nth coll idx)))) + ([coll i not-found] + (when coll + (let [idx (if (neg? i) (+ i (count coll)) i)] + (nth coll idx not-found))))) + +(defn take + {:doc "Takes n elements from the collection, or fewer, if not enough." + :added "0.1"} + [n coll] + (when (pos? n) + (when-let [s (seq coll)] + (cons (first s) (take (dec n) (next s)))))) + +(defn drop + {:doc "Drops n elements from the start of the collection." + :added "0.1"} + [n coll] + (let [s (seq coll)] + (if (and (pos? n) s) + (recur (dec n) (next s)) + s))) + +(defn repeat + ([x] + (cons x (lazy-seq* (fn [] (repeat x))))) + ([n x] + (take n (repeat x)))) + (defn seq-reduce [s f acc] (if (reduced? acc) @acc @@ -1292,6 +1345,20 @@ Creates new maps if the keys are not present." (satisfy IVector Array) (extend-type Array + IObject + (-str [this sb] + (sb "[") + (let [not-first (atom false)] + (reduce + (fn [_ x] + (if @not-first + (sb " ") + (reset! not-first true)) + (-str x sb)) + nil + this)) + (sb "]")) + IPersistentCollection (-conj [arr itm] (conj (pixie.stdlib.persistent-vector/vector-from-array arr) itm)) @@ -1328,6 +1395,31 @@ Creates new maps if the keys are not present." (-seq [this] (sequence this))) +(extend-type ArrayMap + ILookup + (-val-at [this kw not-found] + (let [lst (array-map-to-array this)] + (loop [idx 0] + (if (< idx (count lst)) + (if (= (nth lst idx) kw) + (nth lst (inc idx)) + (recur (+ idx 2))) + not-found)))) + + IReduce + (-reduce [this f init] + (let [lst (array-map-to-array this)] + (loop [acc init + idx 0] + (if (reduced? acc) + @acc + (if (< idx (count lst)) + (let [k (nth lst idx) + v (nth lst (inc idx))] + (recur (f acc (map-entry k v)) + (+ idx 2))) + acc)))))) + (defn array-copy [from from-idx to to-idx size] (loop [idx 0] (when (< idx size) @@ -2585,6 +2677,28 @@ The params can be destructuring bindings, see `(doc let)` for details."} `(fn* ~@name ~@decls)))) +(defmacro defn ^{:doc "Defines a new function." + :signatures [[nm doc? meta? & body]]} + [nm & rest] + (let [meta (if (meta nm) (meta nm) {}) + meta (if (instance? String (first rest)) + (assoc meta :doc (first rest)) + meta) + rest (if (instance? String (first rest)) (next rest) rest) + meta (if (satisfies? IMap (first rest)) + (merge meta (first rest)) + meta) + rest (if (satisfies? IMap (first rest)) (next rest) rest) + meta (if (-contains-key meta :signatures) + meta + (merge meta {:signatures + (if (satisfies? IVector (first rest)) + [(first rest)] + (transduce (map first) conj rest))})) + nm (with-meta nm meta)] + `(def ~nm (fn ~nm ~@rest)))) + + ;; State (defeffect EState diff --git a/pixie/main.pxi b/pixie/main.pxi index 71690463..eff806a4 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -5,6 +5,33 @@ [pixie.ast-output :as ast-out] [pixie.string :as string])) +(defmulti print-stack-at :type) +(defmethod print-stack-at :handler + [{:keys [handler]}] + (println "Handler:" (type handler) ":" handler)) + +(defmethod print-stack-at :default + [{:keys [ast type]}] + (if ast + (let [meta (:meta (describe-internal-object ast))] + (println (:line meta) + "in" + (:file meta) + " " + type + "at" + (str (:line-number meta) + ":" + (:column-number meta))) + (println (apply str (repeat (- (:column-number meta) 2) " ")) + "^")) + (println "Unknown location in " type))) + +(defn print-stack-trace [ks] + (doseq [slice ks] + (doseq [k (:slice (describe-internal-object slice))] + (print-stack-at k)))) + (defn load-file [ns-sym] (let [name (if (string? ns-sym) ns-sym @@ -31,6 +58,7 @@ (with-handler [_ dynamic-var-handler] (binding [reader/*current-ns* 'user] (loop [] + (println "READING FORM") (let [d (reader/read rdr false) _ (println "Compiling " d) analyzed (ast-out/to-ast (compiler/analyze d))] @@ -40,8 +68,9 @@ (try (load-file :pixie.ffi-infer) - (catch :* ex - (println "ERROR Compiling file"))) + (catch :* data + (println "ERROR Compiling file" data) + (print-stack-trace (:ks data)))) (def libedit (ffi-library "libedit.dylib")) diff --git a/pixie/reader.pxi b/pixie/reader.pxi index 214f1405..1202234f 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -202,7 +202,7 @@ form)) (defn deref-reader [rdr] - (cons 'pixie.stdlib/deref (read-inner rdr true))) + (list 'pixie.stdlib/deref (read-inner rdr true))) (defn skip-line-reader [rdr] diff --git a/pixie/vm2/arraymap.py b/pixie/vm2/arraymap.py new file mode 100644 index 00000000..7e946d2f --- /dev/null +++ b/pixie/vm2/arraymap.py @@ -0,0 +1,35 @@ +import pixie.vm2.rt as rt +import pixie.vm2.object as object +from pixie.vm2.object import affirm +from pixie.vm2.code import extend, as_var, extend_var +from pixie.vm2.numbers import Integer +from pixie.vm2.primitives import nil +#import pixie.vm.stdlib as proto +import rpython.rlib.jit as jit +from rpython.rtyper.lltypesystem import lltype +from rpython.rlib.rarithmetic import intmask +from rpython.rlib.objectmodel import we_are_translated +from pixie.vm2.keyword import keyword +from pixie.vm2.array import Array +import pixie.vm2.rt as rt +UNROLL_IF_SMALLER_THAN = 8 + +KW_count = keyword(u"count") + + +class ArrayMap(object.Object): + _type = object.Type(u"pixie.stdlib.ArrayMap") + _immutable_fields_ = ["_list"] + def type(self): + return ArrayMap._type + + def __init__(self, lst): + self._list = lst + + def list_val(self): + return self._list + + +@as_var(u"pixie.stdlib", u"array-map-to-array") +def to_list(this): + return Array(this.list_val()) \ No newline at end of file diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index daa463e2..a53503e0 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -771,7 +771,6 @@ def satisfied_by(self, o): if not isinstance(o, object.Type): o = o.type() - print "SATISFY", o, self._name, o._name, self._protocol._name return self._protocol.satisfies(o) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 9e74605b..45a288e5 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -2,13 +2,32 @@ from pixie.vm2.code import ns_registry, as_var from pixie.vm2.primitives import nil, false from pixie.vm2.array import Array +from pixie.vm2.arraymap import ArrayMap import pixie.vm2.code as code from pixie.vm2.keyword import Keyword, keyword from pixie.vm2.code import BaseCode - +import pixie.vm2.rt as rt import rpython.rlib.jit as jit from pixie.vm2.debugger import expose +kw_type = keyword(u"type") +kw_handler = keyword(u"handler") +kw_invoke = keyword(u"invoke") +kw_ast = keyword(u"ast") +kw_resolve_all = keyword(u"resolve-all") +kw_args = keyword(u"args") +kw_acc = keyword(u"acc") +kw_let = keyword(u"let") +kw_do = keyword(u"do") +kw_delimited_continuation = keyword(u"delimited-continuation") +kw_slice = keyword(u"slice") +kw_meta = keyword(u"meta") +kw_line = keyword(u"line") +kw_file = keyword(u"file") +kw_line_number = keyword(u"line-number") +kw_column_number = keyword(u"column-number") + + class AST(Object): _immutable_fields_ = ["_c_meta"] def __init__(self, meta): @@ -24,6 +43,10 @@ def get_long_location(self): return self._c_meta.get_long_location() return "" + def describe(self): + if self._c_meta != nil: + return ArrayMap([kw_type, kw_ast, kw_meta, self._c_meta.describe()]) + @as_var("pixie.ast.internal", "->Meta") def new_meta(line, file, line_number, column_number): return Meta((line.get_name(), file.get_name(), line_number.int_val()), column_number.int_val()) @@ -57,6 +80,14 @@ def get_long_location(self): return "".join(ld) + def describe(self): + (line, file, line_number) = self._c_line_tuple + return ArrayMap([kw_type, kw_meta, + kw_line, rt.wrap(line), + kw_file, rt.wrap(file), + kw_line_number, rt.wrap(line_number), + kw_column_number, rt.wrap(self._c_column_number)]) + class PrevASTNil(AST): @@ -130,6 +161,11 @@ def new_lookup(name, meta): class Lookup(AST): _immutable_fields_ = ["_c_name"] + _type = Type(u"pixie.ast-internal.Lookup") + + def type(self): + return VDeref._type + def __init__(self, name, meta=nil): assert isinstance(name, Keyword) AST.__init__(self, meta) @@ -281,6 +317,9 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast + def describe(self): + return ArrayMap([kw_type, kw_invoke, kw_ast, self._c_ast]) + @as_var("pixie.ast.internal", "->TailCall") @@ -335,12 +374,24 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_args[len(self._c_acc)] + def describe(self): + return ArrayMap([kw_type, kw_resolve_all, + kw_args, Array(self._c_args), + #kw_locals, Array(self._c_locals), + kw_acc, Array(self._c_acc), + kw_ast, self._c_args[len(self._c_acc)]]) + @as_var("pixie.ast.internal", "->Let") def new_let(names, bindings, body, meta): return Let(names.array_val(), bindings.array_val(), body, meta) class Let(AST): _immutable_fields_ = ["_c_names", "_c_bindings", "_c_body"] + _type = Type(u"pixie.ast-internal.Let") + + def type(self): + return VDeref._type + def __init__(self, names, bindings, body, meta=nil): AST.__init__(self, meta) self._c_names = names @@ -388,6 +439,9 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast + def describe(self): + return ArrayMap([kw_type, kw_let, kw_ast, self._c_ast]) + @as_var("pixie.ast.internal", "->If") def new_if(test, then, els, meta): return If(test, then, els, meta) @@ -481,6 +535,9 @@ def call_continuation(self, val, stack): def get_ast(self): return self._c_ast + def describe(self): + return ArrayMap([kw_type, kw_do, kw_ast, self._c_ast]) + @as_var("pixie.ast.internal", "->VDeref") def new_vderef(in_ns, var_name, meta): return VDeref(in_ns.get_name(), var_name, meta) @@ -491,6 +548,11 @@ def new_vderef(in_ns, var_name, meta): @expose("_c_var") class VDeref(AST): _immutable_fields_ = ["_c_in_ns", "_c_var_name"] + _type = Type(u"pixie.ast-internal.VDeref") + + def type(self): + return VDeref._type + def __init__(self, in_ns, var_name, meta=nil): AST.__init__(self, meta) self._c_in_ns = in_ns @@ -654,6 +716,9 @@ def get_ast(self): def call_continuation(self, val, stack): return val, stack + def describe(self): + return ArrayMap([kw_type, kw_handler, kw_handler, self._handler]) + class DelimitedContinuation(code.NativeFn): _immutable_fields_ = ["_slice[*]"] _type = Type(u"pixie.stdlib.DelmitedContinuation") @@ -664,6 +729,10 @@ def type(self): def __init__(self, slice): self._slice = slice + def describe(self): + return ArrayMap([kw_type, kw_delimited_continuation, + kw_slice, Array([x.describe() for x in self._slice])]) + @jit.unroll_safe def invoke_k(self, args, stack): affirm(len(args) == 1, u"Delmited continuations only take one argument") @@ -671,6 +740,10 @@ def invoke_k(self, args, stack): stack = stack_cons(stack, self._slice[x]) return args[0], stack +@as_var(u"pixie.stdlib", u"describe-internal-object") +def describe_delimited_continuation(k): + return k.describe() + class EffectFunction(code.BaseCode): _type = Type(u"pixie.stdlib.EffectFn") @@ -726,7 +799,6 @@ def slice_stack(self, orig_stack, handler): runtime_error(u"No handler found") - print "Check: ", stack._cont, size, handler, handler.type()._name if (isinstance(stack._cont, Handler) and stack._cont.handler() is handler) or \ (handler is nil and isinstance(stack._cont, Handler) and self._inner_fn.satisfied_by(stack._cont.handler())): size += 1 diff --git a/pixie/vm2/rt.py b/pixie/vm2/rt.py index df649dde..932fcae2 100644 --- a/pixie/vm2/rt.py +++ b/pixie/vm2/rt.py @@ -53,6 +53,7 @@ def wrapper(*args): import pixie.vm2.files import pixie.vm2.stdlib import pixie.vm2.array + import pixie.vm2.arraymap import pixie.vm2.custom_types import pixie.vm2.jit_tables import pixie.vm2.ffi From 13183df7b18d3ea0da4c41bd177dd5107a989d9e Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sat, 18 Jul 2015 15:06:21 -0600 Subject: [PATCH 39/46] bunch of improvements, issues with partition still --- pixie/ast.pxi | 2 +- pixie/bootstrap.pxi | 284 +++++++++++++++++++++++++++++---------- pixie/compiler.pxi | 15 ++- pixie/reader.pxi | 7 +- pixie/stdlib.pxi | 17 ++- pixie/vm2/interpreter.py | 20 ++- pixie/vm2/string.py | 15 ++- 7 files changed, 264 insertions(+), 96 deletions(-) diff --git a/pixie/ast.pxi b/pixie/ast.pxi index 5ff3853a..2a5e8543 100644 --- a/pixie/ast.pxi +++ b/pixie/ast.pxi @@ -80,7 +80,7 @@ (children-keys [this] `[:items])) -(defrecord Env [ns vars locals tail? meta bootstrap?]) +(defrecord Env [ns vars locals tail? meta bootstrap? recur-point]) ;; Ctors diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 9f29ba0a..e6c0223c 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -121,11 +121,14 @@ (c {:ex kw :data data :ks (conj ks k)}) (-throw nil kw data (cons k ks)))))) -(defn throw [kw val] - (-throw nil - kw - val - [])) +(defn throw + ([[kw val]] + (throw kw val)) + ([kw val] + (-throw nil + kw + val + []))) (defn -try [body catches finally] (with-handler [ex (->ExceptionHandler catches finally)] @@ -608,9 +611,110 @@ Creates new maps if the keys are not present." (defn repeat ([x] - (cons x (lazy-seq* (fn [] (repeat x))))) + (cons x (lazy-seq (repeat x)))) ([n x] - (take n (repeat x)))) + (take n (repeat x)))) + +(defn take-while + {:doc "Returns a lazy sequence of successive items from coll while + (pred item) returns true. pred must be free of side-effects. + Returns a transducer when no collection is provided." + :added "0.1"} + ([pred] + (fn [rf] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (if (pred input) + (rf result input) + (reduced result)))))) + ([pred coll] + (lazy-seq + (when-let [s (seq coll)] + (when (pred (first s)) + (cons (first s) (take-while pred (rest s)))))))) + + +(defn drop-while + {:doc "Returns a lazy sequence of the items in coll starting from the + first item for which (pred item) returns logical false. Returns a + stateful transducer when no collection is provided." + :added "0.1"} + ([pred] + (fn [rf] + (let [dv (atom true)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [drop? @dv] + (if drop? + (if (pred input) + result + (do + (reset! dv nil) + (rf result input))) + (rf result input)))))))) + ([pred coll] + (let [step (fn [pred coll] + (let [s (seq coll)] + (if (and s (pred (first s))) + (recur pred (rest s)) + s)))] + (lazy-seq (step pred coll))))) + +;; TODO: use a transient map in the future +(defn group-by + {:doc "Groups the collection into a map keyed by the result of applying f on each element. The value at each key is a vector of elements in order of appearance." + :examples [["(group-by even? [1 2 3 4 5])" nil {false [1 3 5] true [2 4]}] + ["(group-by (partial apply +) [[1 2 3] [2 4] [1 2]])" nil {6 [[1 2 3] [2 4]] 3 [[1 2]]}]] + :signatures [[f coll]] + :added "0.1"} + [f coll] + (reduce (fn [res elem] + (update-in res [(f elem)] (fnil conj []) elem)) + {} + coll)) + +;; TODO: use a transient map in the future +(defn frequencies + {:doc "Returns a map with distinct elements as keys and the number of occurences as values" + :added "0.1"} + [coll] + (reduce (fn [res elem] + (update-in res [elem] (fnil inc 0))) + {} + coll)) + +(defn partition + {:doc "Separates the collection into collections of size n, starting at the beginning, with an optional step size. + +The last element of the result contains the remaining element, not necessarily of size n if +not enough elements were present." + :examples [["(partition 2 [1 2 3 4 5 6])" nil ((1 2) (3 4) (5 6))] + ["(partition 2 [1 2 3 4 5])" nil ((1 2) (3 4) (5))] + ["(partition 2 1 [1 2 3 4 5])" nil ((1 2) (2 3) (3 4) (4 5) (5))]] + :signatures [[n coll] [n step coll]] + :added "0.1"} + ([n coll] (partition n n coll)) + ([n step coll] + (when-let [s (seq coll)] + (lazy-seq + (cons (take n s) (partition n step (drop step s))))))) + +(defn partitionf + {:doc "A generalized version of partition. Instead of taking a constant number of elements, + this function calls f with the remaining collection to determine how many elements to + take." + :examples [["(partitionf first [2 :a, 3 :a :b, 4 :a :b :c])" + nil ((2 :a) (3 :a :b) (4 :a :b :c))]]} + [f coll] + (when-let [s (seq coll)] + (lazy-seq + (let [n (f s)] + (cons (take n s) + (partitionf f (drop n s))))))) (defn seq-reduce [s f acc] (if (reduced? acc) @@ -839,9 +943,7 @@ Creates new maps if the keys are not present." EGenerator (-yield [this val k] - (let [v (cons val (lazy-seq - (k nil)))] - v))) + (cons val (lazy-seq (k nil))))) (defn yield ([g] nil) @@ -2056,6 +2158,7 @@ Creates new maps if the keys are not present." acc)))) (deftype PersistentHashMap [cnt root has-nil? nil-val hash-val meta] + IMap IFn (-invoke [this k] (-val-at this k nil)) @@ -2441,7 +2544,6 @@ user => (refer 'pixie.string :rename '{index-of find}) user => (refer 'pixie.string :exclude '(substring))" :added "0.1"} [from-ns ns-sym & filters] - (println ns-sym) (assert ns-sym "Must provide a ns-sym") (assert from-ns "Must provide a from-ns") (let [ns (or (the-ns ns-sym) (throw [:pixie.stdlib/NamespaceNotFoundException @@ -2451,7 +2553,6 @@ user => (refer 'pixie.string :exclude '(substring))" exclude (:exclude filters) rname (or (:as filters) ns-sym)] - (println "refering " from-ns ns-sym) (-add-refer from-ns ns-sym rname) (if (= :all (:refer filters)) (-refer-all from-ns rname) @@ -2469,7 +2570,6 @@ user => (refer 'pixie.string :exclude '(substring))" (defn load-ns [ns-sym] (assert (not (namespace ns-sym)) "Namespace names must not be namespaced") - (println "LOADING " ns-sym) (or (the-ns ns-sym) (load-file ns-sym))) @@ -2500,34 +2600,25 @@ user => (refer 'pixie.string :exclude '(substring))" (deftype DynamicVar [x] IEffect (-effect-val [this y] - (println "Effect Val" y) (fn val-fn [s] y)) (-effect-finally [this f] - (println "Effect Return " f) (f x)) EDynamicVarEnv (-dynamic-var-get [this var k] - (println "lookup") (fn lookup-fn [s] - (println "lookup -> " s k) ((k (get s var)) s))) (-dynamic-var-set [this var val k] - (println "call set " var val) (fn [s] - (println "Setting to | " var val) ((k nil) (assoc s var val)))) (-dynamic-get-vars [this k] - (println "get vars" this k) (fn [s] - (println "getting vars " s) ((k s) s))) (-dynamic-set-vars [this s' k] - (println "set vars" this s') (fn set-vars [s] ((k nil) s')))) @@ -2538,29 +2629,27 @@ user => (refer 'pixie.string :exclude '(substring))" + +;; LibC Stuff +(def load-paths (atom ["." ""])) + +(defn ffi-library [nm] + (reduce + (fn [_ x] + (when-let [l (-ffi-library (str x (name nm)))] + (reduced l))) + nil + @load-paths)) + + +(def libc (ffi-library pixie.platform/lib-c-name)) + ;; -;; Multimethod stuff -#_(comment -(deftype MultiMethod [name dispatch-fn default-val methods] - IFn - (-invoke [self & args] - (let [dispatch-val (apply dispatch-fn args) - method (if (contains? @methods dispatch-val) - (get @methods dispatch-val) - (get @methods default-val)) - _ (assert method (str "no method defined for " dispatch-val " on " name))] - (try - (apply method args) - (catch ex - (throw (add-exception-info ex (str "In multimethod " - name - " dispatching on " - dispatch-val - "\n") args))))))) +;; Mutimethods (defmacro defmulti {:doc "Define a multimethod, which dispatches to its methods based on dispatch-fn." @@ -2579,7 +2668,7 @@ user => (refer 'pixie.string :exclude '(substring))" [meta args]) dispatch-fn (first args) options (apply hashmap (next args))] - `(def ~name (->MultiMethod ~(str name) ~dispatch-fn ~(get options :default :default) (atom {}))))) + `(def ~name (->MultiMethod ~dispatch-fn ~(get options :default :default) (atom {}))))) (defmacro defmethod {:doc "Define a method of a multimethod. See `(doc defmulti)` for details." @@ -2593,30 +2682,6 @@ user => (refer 'pixie.string :exclude '(substring))" ~dispatch-val (fn ~params ~@body)) ~name))) -) - -;; End Multimethods - -;; LibC Stuff -(def load-paths (atom ["." ""])) - -(defn ffi-library [nm] - (reduce - (fn [_ x] - (when-let [l (-ffi-library (str x (name nm)))] - (reduced l))) - nil - @load-paths)) - - -(def libc (ffi-library pixie.platform/lib-c-name)) - - -;; - - - -;; Mutimethods (deftype MultiMethod [dispatch-fn default-val methods] IFn @@ -2628,9 +2693,7 @@ user => (refer 'pixie.string :exclude '(substring))" (apply method args)))) - -;; - +;; End Multimethods (def gensym-state (atom 0)) (defn gensym @@ -2649,7 +2712,6 @@ The following two forms are allowed: The params can be destructuring bindings, see `(doc let)` for details."} [& decls] - (println "FN" (seq decls)) (let [name (if (symbol? (first decls)) [(first decls)] nil) decls (if name (next decls) decls) decls (cond @@ -2657,7 +2719,6 @@ The params can be destructuring bindings, see `(doc let)` for details."} ;(satisfies? ISeqable (first decls)) decls ;:else (throw (str "expected a vector or a seq, got a " (type decls))) :else decls) - _ (println ">>>" name decls) decls (seq (map (fn [[argv & body]] (let [names (vec (map #(if (= % '&) '& (gensym "arg__")) argv)) bindings (loop [i 0 bindings []] @@ -2699,6 +2760,89 @@ The params can be destructuring bindings, see `(doc let)` for details."} `(def ~nm (fn ~nm ~@rest)))) +(defn destructure [binding expr] + (cond + (symbol? binding) [binding expr] + (vector? binding) (let [name (gensym "vec__")] + (reduce conj [name expr] + (destructure-vector binding name))) + (map? binding) (let [name (gensym "map__")] + (reduce conj [name expr] + (destructure-map binding name))) + :else (throw [:pixie.stdlib/AssertionException + (str "unsupported binding form: " binding)]))) + +(defn destructure-vector [binding-vector expr] + (loop [bindings (seq binding-vector) + i 0 + res []] + (if bindings + (let [binding (first bindings)] + (cond + (= binding '&) (recur (nnext bindings) + (inc (inc i)) + (reduce conj res (destructure (second bindings) `(nthnext ~expr ~i)))) + (= binding :as) (reduce conj res (destructure (second bindings) expr)) + :else (recur (next bindings) + (inc i) + (reduce conj res (destructure (first bindings) `(nth ~expr ~i nil)))))) + res))) + +(defn destructure-map [binding-map expr] + (let [defaults (or (:or binding-map) {}) + res + (loop [bindings (seq binding-map) + res []] + (if bindings + (let [binding (key (first bindings)) + binding-key (val (first bindings))] + (if (contains? #{:or :as :keys} binding) + (recur (next bindings) res) + (recur (next bindings) + (reduce conj res (destructure binding `(get ~expr ~binding-key ~(get defaults binding))))))) + res)) + expand-with (fn [convert] #(vector % `(get ~expr ~(convert %) ~(get defaults %)))) + res (if (contains? binding-map :keys) (transduce (map (expand-with (comp keyword name))) concat res (get binding-map :keys)) res) + res (if (contains? binding-map :as) + (reduce conj res [(get binding-map :as) expr]) + res)] + res)) + +(defmacro let + {:doc "Makes the bindings availlable in the body. + +The bindings must be a vector of binding-expr pairs. The binding can be a destructuring +binding, as below. + +Vector destructuring: + [x y z] binds the first three elements of the collection to x, y and z + [x y & rest] binds rest to the elements after the first two elements of the collection + [x y :as v] binds the value of the complete collection to v + +Map destructuring: + {a :a, b :b} binds a and b to the values associated with :a and :b + {a :a :as m} binds the value of the complete collection to m + {a :a :or {a 42}} binds a to the value associated with :a, or 42, if not present + {:keys [a b c]} binds a, b and c to the values associated with :a, :b and :c + +All these forms can be combined and nested, in the example below: + +(let [[x y [z :as iv] :as v] [1 2 [3 4 5] 6 7] + {a :a [b c {:keys [d]}] :more :or {a 42}} {:a 1, :more [1 2 {:d 3, :e 4}]}] + ...) + +For more information, see http://clojure.org/special_forms#binding-forms"} + [bindings & body] + (let* [destructured-bindings (transduce (map (fn let-foo [args] + (assert (= 2 (count args)) (str "Bindings must be in pairs, not " args + " " (meta (first args)))) + (apply destructure args))) + concat + [] + (partition 2 bindings))] + `(let* ~destructured-bindings + ~@body))) + ;; State (defeffect EState diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index e41a42c4..238498aa 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -90,19 +90,20 @@ (let [[name body] (if (symbol? (first body)) [(first body) (next body)] - [(gensym "fn_") + [(gensym "ann-fn_") body]) arities (if (vector? (first body)) [body] body) + new-env (assoc env :recur-point name) analyzed-bodies (reduce - (partial analyze-fn-body env name) + (partial analyze-fn-body new-env name) {} arities)] (->Fn name (vals analyzed-bodies) form - env))) + new-env))) (defmethod analyze-seq 'try [env [_ & body :as form]] @@ -184,7 +185,7 @@ (defmethod analyze-seq 'loop* [env [_ bindings & body]] (let [parted (partition 2 bindings)] - (analyze-form env + (analyze-form (assoc env :recur-point '__loop__fn__) `((fn ~'__loop__fn__ ~(mapv first parted) ~@body) ~@(mapv second parted))))) @@ -192,7 +193,8 @@ (defmethod analyze-seq 'recur [env [_ & args]] (assert (:tail? env) "Can only recur at tail position") - (analyze-form env `(~'__loop__fn__ ~@args))) + (assert (:recur-point env) "Don't have a point to recur to") + (analyze-form env `(~(:recur-point env) ~@args))) (defmethod analyze-seq 'var [env [_ nm]] @@ -376,7 +378,8 @@ {} true nil - bootstrap?)) + bootstrap? + nil)) (defn analyze diff --git a/pixie/reader.pxi b/pixie/reader.pxi index 1202234f..3d4dca9d 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -270,6 +270,9 @@ (keyword (str (namespace itm) "/" (name itm))) (keyword (name itm)))))) +(defn quote-reader [rdr] + (list 'quote (read-inner rdr true))) + (def handlers (switch-table \( (make-coll-reader list \( \)) @@ -284,7 +287,8 @@ \; skip-line-reader \^ meta-reader \~ unquote-reader - \" literal-string-reader)) + \" literal-string-reader + \' quote-reader)) (defn read-number [rdr ch] (let [sb (string-builder) @@ -324,6 +328,7 @@ (recur sb-fn))))))) (defn interpret-symbol [s] + (println "interpret sym " (= s "nil") s) (cond (= s "true") true (= s "false") false diff --git a/pixie/stdlib.pxi b/pixie/stdlib.pxi index 39bcbc3e..02aecef0 100644 --- a/pixie/stdlib.pxi +++ b/pixie/stdlib.pxi @@ -1136,6 +1136,17 @@ Creates new maps if the keys are not present." [sym] `(resolve-in (this-ns-name) ~sym)) +(defmacro binding [bindings & body] + (let [bindings (apply hashmap bindings) + set-vars (reduce (fn [res binding] + (conj res `(set! (resolve (quote ~(key binding))) ~(val binding)))) + [] + bindings)] + `(do (push-binding-frame!) + ~@set-vars + (let [ret (do ~@body)] + (pop-binding-frame!) + ret)))) (defmacro ns [nm & body] (let [bmap (reduce (fn [m b] @@ -1276,11 +1287,7 @@ Creates new maps if the keys are not present." (puts (apply pr-str args)) nil) -(defn repeat - ([x] - (cons x (lazy-seq* (fn [] (repeat x))))) - ([n x] - (take n (repeat x)))) + (defn repeatedly {:doc "Returns a lazy seq that contains the return values of repeated calls to f. diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 45a288e5..42ce3897 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -226,10 +226,10 @@ def interpret(self, _, locals, stack): for n in self._c_closed_overs: locals_prefix = Locals(n, Locals.get_local(locals, n), locals_prefix) - return InterpretedFn(self._c_name, self._c_args, locals_prefix, self._c_body), stack + return InterpretedFn(self._c_name, self._c_args, locals_prefix, self._c_body, self), stack class InterpretedFn(code.BaseCode): - _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name", "_c_arg_names"] + _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name", "_c_arg_names", "_c_fn_def_ast"] _type = Type(u"pixie.stdlib.InterpretedFn") def type(self): @@ -241,7 +241,7 @@ def to_repr(self): def to_str(self): return u"" - def __init__(self, name, arg_names, locals_prefix, ast): + def __init__(self, name, arg_names, locals_prefix, ast, fn_def_ast): assert isinstance(name, Keyword) code.BaseCode.__init__(self) self._c_arg_names = arg_names @@ -251,6 +251,7 @@ def __init__(self, name, arg_names, locals_prefix, ast): else: self._c_locals = locals_prefix self._c_fn_ast = ast + self._c_fn_def_ast = fn_def_ast def invoke_k(self, args, stack): return self.invoke_k_with(args, stack, self) @@ -262,11 +263,13 @@ def invoke_k_with(self, args, stack, self_fn): locals = Locals(self._c_name, self_fn, locals) if not len(args) == len(self._c_arg_names): + runtime_error(u"Wrong number args to" + self.to_repr() + u", got " + unicode(str(len(args))) + - u" expected " + unicode(str(len(self._c_arg_names))), + u" expected " + unicode(str(len(self._c_arg_names))) + + u"\n" + unicode(self._c_fn_def_ast.get_long_location()), u"pixie.stdlib.ArityException") for idx in range(len(self._c_arg_names)): @@ -645,16 +648,20 @@ def run_stack(val, cont, stack=None, enter_debug=True): try: val, stack = cont.call_continuation(val, stack) ast = cont.get_ast() + except SystemExit: + exit(0) except BaseException as ex: if enter_debug: from pixie.vm2.debugger import debug #debug(cont, stack, val) #print_stacktrace(cont, stack) if not we_are_translated(): + import traceback + print(traceback.format_exc()) print ex val, stack = throw_var.invoke_k([keyword(u"pixie.stdlib/InternalException"), - keyword(u"TODO")], stack) + keyword(u"TODO")], stack_cons(stack, cont)) if stack: cont = stack._cont @@ -796,7 +803,8 @@ def slice_stack(self, orig_stack, handler): ## No hander found if not we_are_translated(): print "Looking for handler, none found, ", handler - runtime_error(u"No handler found") + import sys + sys.exit(0) if (isinstance(stack._cont, Handler) and stack._cont.handler() is handler) or \ diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index efec4a6f..d0a0a1fa 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -1,6 +1,6 @@ import pixie.vm2.rt as rt from pixie.vm2.object import Object, Type, affirm -from pixie.vm2.code import extend, as_var, wrap_fn +from pixie.vm2.code import extend_var, as_var, wrap_fn from pixie.vm2.primitives import nil, true, false from pixie.vm2.numbers import Integer #import pixie.vm2.stdlib as proto @@ -89,12 +89,13 @@ def str_len(self, idx): # return Character(ord(self._str[i])) # return not_found # -# @extend(proto._eq, String) -# def _eq(self, v): -# assert isinstance(self, String) -# if not isinstance(v, String): -# return false -# return true if self._str == v._str else false + +@extend_var(u"pixie.stdlib", u"-eq", String) +def _eq(self, v): + assert isinstance(self, String) + if not isinstance(v, String): + return false + return true if self._str == v._str else false # class Character(Object): _type = Type(u"pixie.stdlib.Character") From 8f8f935ece27ab16085cd3932e447093eeda4417 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Sat, 18 Jul 2015 16:09:01 -0600 Subject: [PATCH 40/46] fix a odd bug with partition --- pixie/bootstrap.pxi | 19 ++++++++++--------- pixie/main.pxi | 6 +++++- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index e6c0223c..8d78e16c 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -700,8 +700,7 @@ not enough elements were present." ([n coll] (partition n n coll)) ([n step coll] (when-let [s (seq coll)] - (lazy-seq - (cons (take n s) (partition n step (drop step s))))))) + (cons (take n s) (lazy-seq (partition n step (drop step s))))))) (defn partitionf {:doc "A generalized version of partition. Instead of taking a constant number of elements, @@ -717,13 +716,14 @@ not enough elements were present." (partitionf f (drop n s))))))) (defn seq-reduce [s f acc] - (if (reduced? acc) - @acc - (if (nil? s) - acc - (seq-reduce (next s) - f - (f acc (first s)))))) + (let [s (seq s)] + (if (reduced? acc) + @acc + (if (nil? s) + acc + (seq-reduce (next s) + f + (f acc (first s))))))) ;; Some logic functions (defn complement @@ -794,6 +794,7 @@ not enough elements were present." (next s)))))) (defn cons [head tail] + (assert (satisfies? ISeqable tail) (str "Can't seq " tail)) (->Cons head tail nil)) diff --git a/pixie/main.pxi b/pixie/main.pxi index eff806a4..adf6c867 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -100,7 +100,11 @@ (println "analyzing ") (let [analyzed (ast-out/to-ast (compiler/analyze d))] (println "analyzed " analyzed) - (println "result :" (pixie.ast.internal/eval analyzed))) + (try + (println "result :" (pixie.ast.internal/eval analyzed)) + (catch :* data + (println "ERROR Compiling file" data) + (print-stack-trace (:ks data))))) (recur))))))) (repl) From ee1136ade79607aaf61261410b8d93f8259e23d8 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 20 Jul 2015 06:49:22 -0600 Subject: [PATCH 41/46] more lines from ffi-infer work --- pixie/ast-output.pxi | 6 ++-- pixie/bootstrap-macros.pxi | 2 +- pixie/bootstrap.pxi | 68 +++++++++++++++++++++++++++++++++++--- pixie/compiler.pxi | 2 +- pixie/vm2/string.py | 13 ++++++-- 5 files changed, 81 insertions(+), 10 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index 84edb33a..a2b22dfb 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -33,9 +33,11 @@ ast/Let (-to-ast [{:keys [bindings body] :as ast}] + (println "BINDING " (map :name bindings) + (map :value bindings)) (iast/->Let (apply array (map #(keyword (name (:name %))) bindings)) - (apply array (map #(to-ast :value %) + (apply array (map #(to-ast (:value %)) bindings)) (to-ast body) (meta-ast ast))) @@ -56,7 +58,7 @@ ast/LetBinding (-to-ast [{:keys [name] :as ast}] - (iast/->Lookup name + (iast/->Lookup (keyword (pixie.stdlib/name name)) (meta-ast ast))) diff --git a/pixie/bootstrap-macros.pxi b/pixie/bootstrap-macros.pxi index 13908917..7078db5e 100644 --- a/pixie/bootstrap-macros.pxi +++ b/pixie/bootstrap-macros.pxi @@ -35,7 +35,7 @@ all-fields fields type-nm (str #_@(:ns env) "." (name nm)) type-decl `(def ~nm (create-type ~(keyword type-nm) - ~all-fields)) + (array ~@all-fields))) inst (gensym) ctor `(defn ~ctor-name ~field-syms (new ~nm diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 8d78e16c..b06ba3a9 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -521,6 +521,37 @@ Creates new maps if the keys are not present." nil (-first x))))) +(defn second + {:doc "Returns the second item in coll, if coll implements IIndexed nth will be used to retrieve + the item from the collection." + :signatures [[coll]] + :added "0.1"} + [coll] + (if (satisfies? IIndexed coll) + (nth coll 1 nil) + (first (next coll)))) + +(defn third + {:doc "Returns the third item in coll, if coll implements IIndexed nth will be used to retrieve + the item from the collection." + :signatures [[coll]] + :added "0.1"} + [coll] + (if (satisfies? IIndexed coll) + (nth coll 2 nil) + (first (next (next coll))))) + +(defn fourth + {:doc "Returns the fourth item in coll, if coll implements IIndexed nth will be used to retrieve + the item from the collection." + :signatures [[coll]] + :added "0.1"} + [coll] + (if (satisfies? IIndexed coll) + (nth coll 3 nil) + (first (next (next (next coll)))))) + + (defn next [x] (if (satisfies? ISeq x) (seq (-next x)) @@ -560,6 +591,22 @@ Creates new maps if the keys are not present." (fn [x & args] (apply f (if (nil? x) else x) args))) +(defn comp + {:doc "Composes the given functions, applying the last function first." + :examples [["((comp inc first) [41 2 3])" nil 42]] + :signatures [[f] [f & fs]] + :added "0.1"} + ([] identity) + ([f] f) + ([f1 f2] + (fn [& args] + (f1 (apply f2 args)))) + ([f1 f2 f3] + (fn [& args] + (f1 (f2 (apply f3 args))))) + ([f1 f2 f3 & fs] + (fn [& args] + (apply (transduce comp (apply list f1 f2 f3 fs)) args)))) (defn last [coll] (if (vector? coll) @@ -788,8 +835,8 @@ not enough elements were present." (if (or (= i 0) (nil? s)) (if (nil? s) - (first s) - not-found) + not-found + (first s)) (recur (dec i) (next s)))))) @@ -2245,7 +2292,9 @@ not enough elements were present." key not-found)))) - + ISeqable + (-seq [this] + (sequence this)) IReduce (-reduce [this f init] @@ -2677,7 +2726,7 @@ user => (refer 'pixie.string :exclude '(substring))" :added "0.1"} [name dispatch-val params & body] `(do - (let [methods (.methods ~name)] + (let [methods (.-methods ~name)] (swap! methods assoc ~dispatch-val (fn ~params @@ -2886,4 +2935,15 @@ For more information, see http://clojure.org/special_forms#binding-forms"} `(with-handler [~n (state)] ~@body)) +;; String stuff +(in-ns :pixie.string) + +(defn substring + ([s start] + (substring s start (count s))) + ([s start end] + (-substring s start end))) + +(in-ns :pixie.stdlib) +;; End String diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index 238498aa..b9e7a530 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -166,7 +166,7 @@ (assert (even? (count bindings)) "Let requires an even number of bindings") (let [parted (partition 2 bindings) [new-env bindings] (reduce - (fn [[new-env bindings] [name binding-form]] + (fn [[new-env bindings] [name binding-form :as pair]] (let [binding-ast (->LetBinding name (analyze-form (assoc new-env :tail? false) diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index d0a0a1fa..496ae7c1 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -1,5 +1,5 @@ import pixie.vm2.rt as rt -from pixie.vm2.object import Object, Type, affirm +from pixie.vm2.object import Object, Type, affirm, runtime_error from pixie.vm2.code import extend_var, as_var, wrap_fn from pixie.vm2.primitives import nil, true, false from pixie.vm2.numbers import Integer @@ -38,7 +38,16 @@ def str_len(self, idx): i = idx.int_val() return char_cache.intern(ord(self._str[i])) - +@as_var("pixie.string", "-substring") +def substring3(a, start, end): + affirm(isinstance(a, String), u"First argument must be a string") + affirm(isinstance(start, Integer) and isinstance(end, Integer), u"Second and third argument must be integers") + start = start.int_val() + end = end.int_val() + if start >= 0 and end >= 0: + return rt.wrap(a.get_name()[start:end]) + else: + runtime_error(u"Second and third argument must be non-negative integers") # From 649322e4cec25967f86fb45b48a2bd146b7c9b6e Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Mon, 20 Jul 2015 16:13:54 -0600 Subject: [PATCH 42/46] CAN COMPILE FFI-INFER --- pixie/ast-output.pxi | 4 ---- pixie/bootstrap.pxi | 8 ++++++++ pixie/main.pxi | 11 ++++++----- pixie/reader.pxi | 13 ++++++------- 4 files changed, 20 insertions(+), 16 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index a2b22dfb..43059903 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -33,8 +33,6 @@ ast/Let (-to-ast [{:keys [bindings body] :as ast}] - (println "BINDING " (map :name bindings) - (map :value bindings)) (iast/->Let (apply array (map #(keyword (name (:name %))) bindings)) (apply array (map #(to-ast (:value %)) @@ -43,7 +41,6 @@ (meta-ast ast))) ast/Do (-to-ast [{:keys [statements ret] :as ast}] - (println "DO " statements ret) (let [args-array (make-array (inc (count statements)))] (dotimes [idx (count statements)] (aset args-array idx @@ -68,7 +65,6 @@ ast/Invoke (-to-ast [{:keys [args] :as ast}] - (println "INVOKE > " (count args) args) (let [args-array (make-array (count args))] (dotimes [idx (count args)] (aset args-array idx diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index b06ba3a9..65e10425 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -2893,6 +2893,14 @@ For more information, see http://clojure.org/special_forms#binding-forms"} `(let* ~destructured-bindings ~@body))) +(defmacro defmacro + {:doc "Defines a new macro." + :added "0.1"} + [nm & rest] + `(do (defn ~nm ~@rest) + (set-macro! ~nm) + ~nm)) + ;; State (defeffect EState diff --git a/pixie/main.pxi b/pixie/main.pxi index adf6c867..88b9bba7 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -60,11 +60,12 @@ (loop [] (println "READING FORM") (let [d (reader/read rdr false) - _ (println "Compiling " d) - analyzed (ast-out/to-ast (compiler/analyze d))] - (println "GOT " d) - (pixie.ast.internal/eval analyzed) - (recur))))))) + _ (println "Compiling " d)] + (if (not (= d :eof)) + (let [analyzed (ast-out/to-ast (compiler/analyze d))] + (println "GOT " d) + (pixie.ast.internal/eval analyzed) + (recur))))))))) (try (load-file :pixie.ffi-infer) diff --git a/pixie/reader.pxi b/pixie/reader.pxi index 3d4dca9d..6cf26ad0 100644 --- a/pixie/reader.pxi +++ b/pixie/reader.pxi @@ -206,9 +206,9 @@ (defn skip-line-reader [rdr] - (if (identical? \n (read-ch rdr)) + (if (identical? \newline (read-ch rdr)) rdr - (skip-line rdr))) + (skip-line-reader rdr))) (defn meta-reader [rdr] (let [m (read-inner rdr true) @@ -328,7 +328,6 @@ (recur sb-fn))))))) (defn interpret-symbol [s] - (println "interpret sym " (= s "nil") s) (cond (= s "true") true (= s "false") false @@ -337,12 +336,12 @@ (defn read-inner - ([rdr eof-on-error] - (read-inner rdr eof-on-error true)) - ([rdr eof-on-error always-return-form] + ([rdr error-on-eof] + (read-inner rdr error-on-eof true)) + ([rdr error-on-eof always-return-form] (let [ch (eat-whitespace rdr)] (if (identical? ch :eof) - (if eof-on-error + (if error-on-eof (assert-not-eof ch "Unexpeced EOF while reading") ch) (let [m (when (satisfies? IMetadataReader rdr) From 5f02cf0e03dede61a12bb4133948fdb1554d8e0e Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 21 Jul 2015 06:08:11 -0600 Subject: [PATCH 43/46] some JIT work --- Makefile | 2 +- pixie/main.pxi | 2 +- pixie/pxic-writer.pxi | 9 ++- pixie/vm2/ffi.py | 1 - pixie/vm2/interpreter.py | 132 +++++++++++++++++++++++++++++++++------ pixie/vm2/pxic_reader.py | 11 +++- pixie/vm2/stdlib.py | 1 - pixie/vm2/string.py | 2 +- 8 files changed, 133 insertions(+), 27 deletions(-) diff --git a/Makefile b/Makefile index 9fb34f71..704e1b4e 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ all: help EXTERNALS=externals -PYTHON ?= python +PYTHON ?= pypy PYTHONPATH=$$PYTHONPATH:$(EXTERNALS)/pypy diff --git a/pixie/main.pxi b/pixie/main.pxi index 88b9bba7..807c49bf 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -67,7 +67,7 @@ (pixie.ast.internal/eval analyzed) (recur))))))))) -(try +#_(try (load-file :pixie.ffi-infer) (catch :* data (println "ERROR Compiling file" data) diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index db91d02d..ca1b0aec 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -43,7 +43,8 @@ :LINE-META :VAR-CONST :CHAR - :VECTOR]) + :VECTOR + :TAILCALL]) (def *cache* nil) (set-dynamic! (var *cache*)) @@ -219,8 +220,10 @@ (write-meta os ast)) ast/Invoke - (-write-object [{:keys [args] :as ast} os] - (write-tag os INVOKE) + (-write-object [{:keys [args env] :as ast} os] + (write-tag os (if (:tail? env) + TAILCALL + INVOKE)) (write-int-raw os (count args)) (doseq [arg args] (write-object os arg)) diff --git a/pixie/vm2/ffi.py b/pixie/vm2/ffi.py index 9dcd868d..2d415587 100644 --- a/pixie/vm2/ffi.py +++ b/pixie/vm2/ffi.py @@ -138,7 +138,6 @@ def _invoke(self, args): return ret_val def invoke_k(self, args, stack): - print "Invoking ", self._name self = jit.promote(self) return self._invoke(args), stack diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 42ce3897..53542ad0 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -32,6 +32,14 @@ class AST(Object): _immutable_fields_ = ["_c_meta"] def __init__(self, meta): self._c_meta = meta + self._c_fn_parent = nil ## Almost constant, only set once + + def set_fn(self, fn): + self._c_fn_parent = fn + + @jit.elidable_promote() + def get_parent_fn(self): + return self._c_fn_parent def get_short_location(self): if self._c_meta != nil: @@ -110,7 +118,6 @@ def get_ast(self): @as_var("pixie.ast.internal", "->Const") def new_const(val, meta): - print val, meta return Const(val, meta) @expose("_c_val") @@ -179,7 +186,7 @@ def gather_locals(self): @as_var("pixie.ast.internal", "->Fn") def new_fn(name, args, body, meta): - return Fn(name, args.array_val(), body, meta) + return Fn(name, args.array_val(), body, meta=meta) class Fn(AST): _immutable_fields_ = ["_c_name", "_c_args", "_c_body", "_c_closed_overs"] @@ -194,6 +201,8 @@ def __init__(self, name, args, body, closed_overs=[], meta=nil): self._c_args = args self._c_body = body + self._call_cache = {} + glocals = self._c_body.gather_locals() for x in self._c_args: if x in glocals: @@ -211,6 +220,47 @@ def __init__(self, name, args, body, closed_overs=[], meta=nil): self._c_closed_overs = closed_overs + self.set_fn(self) + + def set_fn(self, fn): + self._c_fn_parent = self + self._c_body.set_fn(self) + + def mark_call(self, callee): + #if callee not in self._call_cache: + # print "MARKING", self._c_name.get_name(), " -> ", callee._c_name.get_name() + self._call_cache[callee] = callee + + def get_call_cache(self): + return self._call_cache + + @jit.elidable_promote() + def calls_indirectly(self, callee): + stack = [] + seen = [] + + stack.append(self) + + while stack: + val = stack.pop() + + if val is callee: + return True + + elif val in seen: + continue + + else: + seen.append(val) + for x in val.get_call_cache(): + stack.append(x) + + return False + + + + + def gather_locals(self): glocals = {} @@ -253,6 +303,9 @@ def __init__(self, name, arg_names, locals_prefix, ast, fn_def_ast): self._c_fn_ast = ast self._c_fn_def_ast = fn_def_ast + def get_parent_fn(self): + return self._c_fn_def_ast + def invoke_k(self, args, stack): return self.invoke_k_with(args, stack, self) @@ -293,6 +346,11 @@ def __init__(self, args, meta=nil): AST.__init__(self, meta) self._c_args = args + def set_fn(self, fn): + self._c_fn_parent = fn + for x in self._c_args: + x.set_fn(fn) + def gather_locals(self): glocals = {} for x in self._c_args: @@ -324,16 +382,15 @@ def describe(self): return ArrayMap([kw_type, kw_invoke, kw_ast, self._c_ast]) - @as_var("pixie.ast.internal", "->TailCall") def new_invoke(args, meta): return Invoke(args.array_val(), meta) -class TailCall(AST): +class TailCall(Invoke): _immutable_fields_ = ["_c_args", "_c_fn"] + def __init__(self, args, meta=nil): - AST.__init__(self, meta) - self._c_args = args + Invoke.__init__(self, args, meta) def interpret(self, _, locals, stack): stack = stack_cons(stack, TailCallK(self)) @@ -347,6 +404,12 @@ class TailCallK(InvokeK): def __init__(self, ast): InvokeK.__init__(self, ast) + def mark_call(self, callee): + self.get_parent_fn().mark_call(callee.get_ast().get_parent_fn()) + + def get_fn(self): + return self.get_ast().get_parent_fn() + def get_ast(self): return self._c_ast @@ -401,6 +464,12 @@ def __init__(self, names, bindings, body, meta=nil): self._c_bindings = bindings self._c_body = body + def set_fn(self, fn): + self._c_fn_parent = fn + self._c_body.set_fn(fn) + for x in self._c_bindings: + x.set_fn(fn) + def gather_locals(self): glocals = {} for x in self._c_bindings: @@ -462,6 +531,12 @@ def __init__(self, test, then, els, meta=nil): self._c_then = then self._c_else = els + def set_fn(self, fn): + self._c_fn_parent = fn + self._c_test.set_fn(fn) + self._c_then.set_fn(fn) + self._c_else.set_fn(fn) + def interpret(self, val, locals, stack): stack = stack_cons(stack, IfK(self, locals)) stack = stack_cons(stack, InterpretK(self._c_test, locals)) @@ -506,6 +581,11 @@ def __init__(self, args, meta=nil): AST.__init__(self, meta) self._c_body_asts = args + def set_fn(self, fn): + self._c_fn_parent = fn + for x in self._c_body_asts: + x.set_fn(fn) + @jit.unroll_safe def interpret(self, val, locals, stack): return nil, stack_cons(stack, DoK(self, self._c_body_asts, locals)) @@ -632,24 +712,27 @@ def gather_locals(self): from rpython.rlib.jit import JitDriver from rpython.rlib.objectmodel import we_are_translated -def get_printable_location(ast): - return ast.get_short_location() +def get_printable_location(prev_fn): + + if isinstance(prev_fn, Fn): + return str(prev_fn._c_name.get_name()) + else: + return "" -jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) +jitdriver = JitDriver(greens=["prev_fn"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) throw_var = code.intern_var(u"pixie.stdlib", u"throw") def run_stack(val, cont, stack=None, enter_debug=True): stack = None val = None - ast = cont.get_ast() + prev_fn = nil while True: - jitdriver.jit_merge_point(ast=ast, stack=stack, val=val, cont=cont) + jitdriver.jit_merge_point(prev_fn=prev_fn, stack=stack, val=val, cont=cont) try: val, stack = cont.call_continuation(val, stack) - ast = cont.get_ast() except SystemExit: - exit(0) + break except BaseException as ex: if enter_debug: from pixie.vm2.debugger import debug @@ -668,9 +751,23 @@ def run_stack(val, cont, stack=None, enter_debug=True): stack = stack._parent else: break - - if cont.should_enter_jit: - jitdriver.can_enter_jit(ast=ast, stack=stack, val=val, cont=cont) + if isinstance(cont, TailCallK): + maybe_interpreted = val.array_val()[0] + if isinstance(maybe_interpreted, InterpretedFn): + fn = maybe_interpreted.get_parent_fn() + else: + fn = nil + if prev_fn is not nil and fn is not nil: + prev_fn.mark_call(fn) + prev_prev_fn = prev_fn + prev_fn = fn + if prev_fn is not nil and prev_fn.calls_indirectly(prev_prev_fn): + #print "LOOPING ", prev_fn._c_name.get_name(), prev_prev_fn._c_name.get_name() + jitdriver.can_enter_jit(prev_fn=prev_fn, stack=stack, val=val, cont=cont) + elif cont.get_ast() is nil or cont.get_ast() is None: + prev_fn = nil + else: + prev_fn = cont.get_ast().get_parent_fn() return val @@ -803,8 +900,7 @@ def slice_stack(self, orig_stack, handler): ## No hander found if not we_are_translated(): print "Looking for handler, none found, ", handler - import sys - sys.exit(0) + raise SystemExit() if (isinstance(stack._cont, Handler) and stack._cont.handler() is handler) or \ diff --git a/pixie/vm2/pxic_reader.py b/pixie/vm2/pxic_reader.py index b9aa228e..8e32e23b 100644 --- a/pixie/vm2/pxic_reader.py +++ b/pixie/vm2/pxic_reader.py @@ -59,7 +59,8 @@ def get_cache(self, idx): "LINE_META", "VAR_CONST", "CHAR", - "VECTOR"] + "VECTOR", + "TAILCALL"] for idx, x in enumerate(bytecodes): globals()[x] = idx @@ -128,6 +129,14 @@ def read_object(os): meta = read_object(os) return ast.Invoke(args, meta=meta) + elif tag == TAILCALL: + args = [None] * read_raw_int(os) + for x in range(len(args)): + args[x] = read_object(os) + + meta = read_object(os) + return ast.TailCall(args, meta=meta) + elif tag == NEW_CACHED_OBJECT: idx = os.get_cache_idx() o = read_object(os) diff --git a/pixie/vm2/stdlib.py b/pixie/vm2/stdlib.py index fd54ee54..b28feb12 100644 --- a/pixie/vm2/stdlib.py +++ b/pixie/vm2/stdlib.py @@ -299,7 +299,6 @@ def _var(ns, nm): ns = code.ns_registry.find_or_make(ns.get_name()) var = ns.resolve_in_ns_ex(nm.get_ns(), nm.get_name()) - print "Resolved ", ns, nm.get_name(), var return var if var is not None else nil diff --git a/pixie/vm2/string.py b/pixie/vm2/string.py index 496ae7c1..586af663 100644 --- a/pixie/vm2/string.py +++ b/pixie/vm2/string.py @@ -247,4 +247,4 @@ def str_replace(s, sfrom, sto): affirm(isinstance(s, String), u"Expected string") affirm(isinstance(sfrom, String), u"Expected string") affirm(isinstance(sto, String), u"Expected string") - return rt.wrap(s.get_name().replace(sfrom.get_name(), sto.get_name())) \ No newline at end of file + return rt.wrap(s.get_name().replace(sfrom.get_name()[0], sto.get_name()[0])) \ No newline at end of file From 43d75caf630d11810bf4a6821e25a15080520fe8 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Tue, 21 Jul 2015 23:29:20 -0600 Subject: [PATCH 44/46] work on the jit, needs more tweaks --- pixie/ast-output.pxi | 14 +++- pixie/ast.pxi | 15 +++++ pixie/compiler.pxi | 8 ++- pixie/main.pxi | 9 ++- pixie/pxic-writer.pxi | 14 ++-- pixie/vm2/interpreter.py | 142 +++++++-------------------------------- pixie/vm2/pxic_reader.py | 6 +- target2.py | 13 +++- 8 files changed, 90 insertions(+), 131 deletions(-) diff --git a/pixie/ast-output.pxi b/pixie/ast-output.pxi index 43059903..9dda8a8e 100644 --- a/pixie/ast-output.pxi +++ b/pixie/ast-output.pxi @@ -64,15 +64,25 @@ (iast/->Const form (meta-ast ast))) ast/Invoke - (-to-ast [{:keys [args] :as ast}] + (-to-ast [{:keys [args env] :as ast}] (let [args-array (make-array (count args))] (dotimes [idx (count args)] (aset args-array idx (to-ast (nth args idx)))) - + (iast/->Invoke args-array (meta-ast ast)))) + ast/Recur + (-to-ast [{:keys [args env] :as ast}] + (let [args-array (make-array (count args))] + (dotimes [idx (count args)] + (aset args-array idx + (to-ast (nth args idx)))) + + (iast/->Recur args-array + (meta-ast ast)))) + ast/Var (-to-ast [{:keys [ns var-name] :as ast}] (iast/->VDeref (name ns) diff --git a/pixie/ast.pxi b/pixie/ast.pxi index 2a5e8543..259cba2c 100644 --- a/pixie/ast.pxi +++ b/pixie/ast.pxi @@ -52,6 +52,11 @@ (children-keys [this] `[:value])) +(defrecord Recur [args env] + IAst + (children-keys [this] + `[:args])) + (defrecord LocalMacro [name respace form env]) @@ -152,6 +157,16 @@ form env))) + Invoke + (simplify-ast [{:keys [args env] :as ast}] + (let [first-arg (first args)] + (if (and (:tail? env) + (and (instance? Binding first-arg) + (= (:name first-arg) + (:recur-point env)))) + (->Recur args env) + ast))) + Vector (simplify-ast [{:keys [items form env]}] (make-invoke-var-ast diff --git a/pixie/compiler.pxi b/pixie/compiler.pxi index b9e7a530..1caaedab 100644 --- a/pixie/compiler.pxi +++ b/pixie/compiler.pxi @@ -95,7 +95,9 @@ arities (if (vector? (first body)) [body] body) - new-env (assoc env :recur-point name) + new-env (assoc env + :recur-point name + :tail? true) analyzed-bodies (reduce (partial analyze-fn-body new-env name) {} @@ -178,7 +180,9 @@ [env []] parted)] (->Let bindings - (analyze-form new-env `(do ~@body)) + (analyze-form (assoc new-env + :tail? (:tail? env)) + `(do ~@body)) form env))) diff --git a/pixie/main.pxi b/pixie/main.pxi index 807c49bf..eb6d3598 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -99,14 +99,19 @@ (let [d (reader/read rdr false)] (println "got " d) (println "analyzing ") - (let [analyzed (ast-out/to-ast (compiler/analyze d))] + (let [analyzed (try + (ast-out/to-ast (compiler/analyze d)) + (catch :* data + (println "ERROR Analyzing" data) + (print-stack-trace (:ks data))))] (println "analyzed " analyzed) (try (println "result :" (pixie.ast.internal/eval analyzed)) (catch :* data (println "ERROR Compiling file" data) (print-stack-trace (:ks data))))) - (recur))))))) + (if (not (= d :exit-repl)) + (recur)))))))) (repl) (println "done") diff --git a/pixie/pxic-writer.pxi b/pixie/pxic-writer.pxi index ca1b0aec..2c030b75 100644 --- a/pixie/pxic-writer.pxi +++ b/pixie/pxic-writer.pxi @@ -44,7 +44,7 @@ :VAR-CONST :CHAR :VECTOR - :TAILCALL]) + :RECUR]) (def *cache* nil) (set-dynamic! (var *cache*)) @@ -221,9 +221,15 @@ ast/Invoke (-write-object [{:keys [args env] :as ast} os] - (write-tag os (if (:tail? env) - TAILCALL - INVOKE)) + (write-tag os INVOKE) + (write-int-raw os (count args)) + (doseq [arg args] + (write-object os arg)) + (write-meta os ast)) + + ast/Recur + (-write-object [{:keys [args env] :as ast} os] + (write-tag os RECUR) (write-int-raw os (count args)) (doseq [arg args] (write-object os arg)) diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 53542ad0..9f04ebbf 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -32,14 +32,6 @@ class AST(Object): _immutable_fields_ = ["_c_meta"] def __init__(self, meta): self._c_meta = meta - self._c_fn_parent = nil ## Almost constant, only set once - - def set_fn(self, fn): - self._c_fn_parent = fn - - @jit.elidable_promote() - def get_parent_fn(self): - return self._c_fn_parent def get_short_location(self): if self._c_meta != nil: @@ -118,6 +110,7 @@ def get_ast(self): @as_var("pixie.ast.internal", "->Const") def new_const(val, meta): + print val, meta return Const(val, meta) @expose("_c_val") @@ -201,8 +194,6 @@ def __init__(self, name, args, body, closed_overs=[], meta=nil): self._c_args = args self._c_body = body - self._call_cache = {} - glocals = self._c_body.gather_locals() for x in self._c_args: if x in glocals: @@ -220,47 +211,6 @@ def __init__(self, name, args, body, closed_overs=[], meta=nil): self._c_closed_overs = closed_overs - self.set_fn(self) - - def set_fn(self, fn): - self._c_fn_parent = self - self._c_body.set_fn(self) - - def mark_call(self, callee): - #if callee not in self._call_cache: - # print "MARKING", self._c_name.get_name(), " -> ", callee._c_name.get_name() - self._call_cache[callee] = callee - - def get_call_cache(self): - return self._call_cache - - @jit.elidable_promote() - def calls_indirectly(self, callee): - stack = [] - seen = [] - - stack.append(self) - - while stack: - val = stack.pop() - - if val is callee: - return True - - elif val in seen: - continue - - else: - seen.append(val) - for x in val.get_call_cache(): - stack.append(x) - - return False - - - - - def gather_locals(self): glocals = {} @@ -303,9 +253,6 @@ def __init__(self, name, arg_names, locals_prefix, ast, fn_def_ast): self._c_fn_ast = ast self._c_fn_def_ast = fn_def_ast - def get_parent_fn(self): - return self._c_fn_def_ast - def invoke_k(self, args, stack): return self.invoke_k_with(args, stack, self) @@ -346,11 +293,6 @@ def __init__(self, args, meta=nil): AST.__init__(self, meta) self._c_args = args - def set_fn(self, fn): - self._c_fn_parent = fn - for x in self._c_args: - x.set_fn(fn) - def gather_locals(self): glocals = {} for x in self._c_args: @@ -382,34 +324,29 @@ def describe(self): return ArrayMap([kw_type, kw_invoke, kw_ast, self._c_ast]) -@as_var("pixie.ast.internal", "->TailCall") + +@as_var("pixie.ast.internal", "->Recur") def new_invoke(args, meta): - return Invoke(args.array_val(), meta) + return Recur(args.array_val(), meta) -class TailCall(Invoke): +class Recur(Invoke): _immutable_fields_ = ["_c_args", "_c_fn"] - def __init__(self, args, meta=nil): Invoke.__init__(self, args, meta) + self._c_args = args def interpret(self, _, locals, stack): - stack = stack_cons(stack, TailCallK(self)) + stack = stack_cons(stack, RecurK(self)) stack = stack_cons(stack, ResolveAllK(self._c_args, locals, [])) stack = stack_cons(stack, InterpretK(self._c_args[0], locals)) return nil, stack -class TailCallK(InvokeK): +class RecurK(InvokeK): _immutable_ = True should_enter_jit = True def __init__(self, ast): InvokeK.__init__(self, ast) - def mark_call(self, callee): - self.get_parent_fn().mark_call(callee.get_ast().get_parent_fn()) - - def get_fn(self): - return self.get_ast().get_parent_fn() - def get_ast(self): return self._c_ast @@ -464,12 +401,6 @@ def __init__(self, names, bindings, body, meta=nil): self._c_bindings = bindings self._c_body = body - def set_fn(self, fn): - self._c_fn_parent = fn - self._c_body.set_fn(fn) - for x in self._c_bindings: - x.set_fn(fn) - def gather_locals(self): glocals = {} for x in self._c_bindings: @@ -531,12 +462,6 @@ def __init__(self, test, then, els, meta=nil): self._c_then = then self._c_else = els - def set_fn(self, fn): - self._c_fn_parent = fn - self._c_test.set_fn(fn) - self._c_then.set_fn(fn) - self._c_else.set_fn(fn) - def interpret(self, val, locals, stack): stack = stack_cons(stack, IfK(self, locals)) stack = stack_cons(stack, InterpretK(self._c_test, locals)) @@ -581,11 +506,6 @@ def __init__(self, args, meta=nil): AST.__init__(self, meta) self._c_body_asts = args - def set_fn(self, fn): - self._c_fn_parent = fn - for x in self._c_body_asts: - x.set_fn(fn) - @jit.unroll_safe def interpret(self, val, locals, stack): return nil, stack_cons(stack, DoK(self, self._c_body_asts, locals)) @@ -712,27 +632,24 @@ def gather_locals(self): from rpython.rlib.jit import JitDriver from rpython.rlib.objectmodel import we_are_translated -def get_printable_location(prev_fn): +def get_printable_location(ast): + return ast.get_short_location() - if isinstance(prev_fn, Fn): - return str(prev_fn._c_name.get_name()) - else: - return "" - -jitdriver = JitDriver(greens=["prev_fn"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) +jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) throw_var = code.intern_var(u"pixie.stdlib", u"throw") def run_stack(val, cont, stack=None, enter_debug=True): stack = None val = None - prev_fn = nil + ast = cont.get_ast() while True: - jitdriver.jit_merge_point(prev_fn=prev_fn, stack=stack, val=val, cont=cont) + jitdriver.jit_merge_point(ast=ast, stack=stack, val=val, cont=cont) try: val, stack = cont.call_continuation(val, stack) + ast = cont.get_ast() except SystemExit: - break + raise except BaseException as ex: if enter_debug: from pixie.vm2.debugger import debug @@ -751,23 +668,10 @@ def run_stack(val, cont, stack=None, enter_debug=True): stack = stack._parent else: break - if isinstance(cont, TailCallK): - maybe_interpreted = val.array_val()[0] - if isinstance(maybe_interpreted, InterpretedFn): - fn = maybe_interpreted.get_parent_fn() - else: - fn = nil - if prev_fn is not nil and fn is not nil: - prev_fn.mark_call(fn) - prev_prev_fn = prev_fn - prev_fn = fn - if prev_fn is not nil and prev_fn.calls_indirectly(prev_prev_fn): - #print "LOOPING ", prev_fn._c_name.get_name(), prev_prev_fn._c_name.get_name() - jitdriver.can_enter_jit(prev_fn=prev_fn, stack=stack, val=val, cont=cont) - elif cont.get_ast() is nil or cont.get_ast() is None: - prev_fn = nil - else: - prev_fn = cont.get_ast().get_parent_fn() + + if isinstance(cont, RecurK): + jitdriver.can_enter_jit(ast=ast, stack=stack, val=val, cont=cont) + return val @@ -834,8 +738,12 @@ def __init__(self, slice): self._slice = slice def describe(self): + arr = [None] * len(self._slice) + for idx, x in enumerate(self._slice): + arr[idx] = x.describe() + return ArrayMap([kw_type, kw_delimited_continuation, - kw_slice, Array([x.describe() for x in self._slice])]) + kw_slice, Array(arr)]) @jit.unroll_safe def invoke_k(self, args, stack): @@ -900,8 +808,8 @@ def slice_stack(self, orig_stack, handler): ## No hander found if not we_are_translated(): print "Looking for handler, none found, ", handler - raise SystemExit() + raise SystemExit() if (isinstance(stack._cont, Handler) and stack._cont.handler() is handler) or \ (handler is nil and isinstance(stack._cont, Handler) and self._inner_fn.satisfied_by(stack._cont.handler())): diff --git a/pixie/vm2/pxic_reader.py b/pixie/vm2/pxic_reader.py index 8e32e23b..2c3c7794 100644 --- a/pixie/vm2/pxic_reader.py +++ b/pixie/vm2/pxic_reader.py @@ -60,7 +60,7 @@ def get_cache(self, idx): "VAR_CONST", "CHAR", "VECTOR", - "TAILCALL"] + "RECUR"] for idx, x in enumerate(bytecodes): globals()[x] = idx @@ -129,13 +129,13 @@ def read_object(os): meta = read_object(os) return ast.Invoke(args, meta=meta) - elif tag == TAILCALL: + elif tag == RECUR: args = [None] * read_raw_int(os) for x in range(len(args)): args[x] = read_object(os) meta = read_object(os) - return ast.TailCall(args, meta=meta) + return ast.Recur(args, meta=meta) elif tag == NEW_CACHED_OBJECT: idx = os.get_cache_idx() diff --git a/target2.py b/target2.py index ff35e5ec..e24e4d21 100644 --- a/target2.py +++ b/target2.py @@ -44,6 +44,17 @@ def entry_point(args): val = testit(max) return 43 +def entry_point0(): + #s = rt.wrap(u"Foo") + from pixie.vm2.string import String + v = parse_number(u"1") + + s = String(u"Foo") + max = 10000 #int(args[1]) + + val = testit(max) + return 43 + ## JIT STUFF @@ -80,7 +91,7 @@ def run_debug(argv): # first annotate and rtype try: - interp, graph = get_interpreter(entry_point, [], backendopt=False, + interp, graph = get_interpreter(entry_point0, [], backendopt=False, #config=config, #type_system=config.translation.type_system, policy=Policy()) From 37cd1b105aab9e66d53fa51166670375b8483f62 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Thu, 23 Jul 2015 06:27:36 -0600 Subject: [PATCH 45/46] greatly improved jit performance --- pixie/vm2/code.py | 10 ++++++- pixie/vm2/interpreter.py | 57 +++++++++++++++++++++++++++++----------- 2 files changed, 50 insertions(+), 17 deletions(-) diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index a53503e0..5c56a142 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -660,11 +660,19 @@ def get(self, name, default): class NamespaceRegistry(py_object): def __init__(self): self._registry = {} + self._rev = 0 - def find_or_make(self, name): + @jit.elidable_promote() + def _find_ns(self, name, rev): #affirm(isinstance(name, unicode), u"Namespace names must be unicode") v = self._registry.get(name, None) + return v + + + def find_or_make(self, name): + v = self._find_ns(name, self._rev) if v is None: + self._rev += 1 v = Namespace(name) self._registry[name] = v v.include_stdlib() diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index 9f04ebbf..e7327135 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -27,6 +27,22 @@ kw_line_number = keyword(u"line-number") kw_column_number = keyword(u"column-number") +class Args(Object): + _type = Type(u"pixie.interpreter.Args") + _immutable_fields = ["_c_list[*]"] + + def type(self): + return Args._type + + def __init__(self, lst): + self._c_list = lst + + def c_array_value(self): + return self._c_list + + + + class AST(Object): _immutable_fields_ = ["_c_meta"] @@ -283,7 +299,7 @@ def new_invoke(args, meta): return Invoke(args.array_val(), meta) class Invoke(AST): - _immutable_fields_ = ["_c_args", "_c_fn"] + _immutable_fields_ = ["_c_args[*]"] _type = Type(u"pixie.ast-internal.Invoke") def type(self): @@ -302,19 +318,28 @@ def gather_locals(self): def interpret(self, _, locals, stack): stack = stack_cons(stack, InvokeK(self)) - stack = stack_cons(stack, ResolveAllK(self._c_args, locals, [])) + stack = stack_cons(stack, ResolveAllK(self, locals, [])) stack = stack_cons(stack, InterpretK(self._c_args[0], locals)) return nil, stack + @jit.elidable_promote() + def arg_count(self): + return len(self._c_args) + + @jit.elidable_promote() + def get_arg(self, idx): + return self._c_args[idx] + + class InvokeK(Continuation): _immutable_ = True def __init__(self, ast): self._c_ast = ast def call_continuation(self, val, stack): - assert isinstance(val, Array) - fn = val._list[0] - args = val._list[1:] + assert isinstance(val, Args) + fn = val._c_list[0] + args = val._c_list[1:] return fn.invoke_k(args, stack) def get_ast(self): @@ -325,6 +350,7 @@ def describe(self): + @as_var("pixie.ast.internal", "->Recur") def new_invoke(args, meta): return Recur(args.array_val(), meta) @@ -337,7 +363,7 @@ def __init__(self, args, meta=nil): def interpret(self, _, locals, stack): stack = stack_cons(stack, RecurK(self)) - stack = stack_cons(stack, ResolveAllK(self._c_args, locals, [])) + stack = stack_cons(stack, ResolveAllK(self, locals, [])) stack = stack_cons(stack, InterpretK(self._c_args[0], locals)) return nil, stack @@ -353,7 +379,7 @@ def get_ast(self): class ResolveAllK(Continuation): _immutable_ = True def __init__(self, args, locals, acc): - self._c_args = args + self._c_args_ast = args self._c_locals = locals self._c_acc = acc @@ -366,23 +392,23 @@ def append_to_acc(self, val): return acc def call_continuation(self, val, stack): - if len(self._c_acc) + 1 < len(self._c_args): - stack = stack_cons(stack, ResolveAllK(self._c_args, self._c_locals, self.append_to_acc(val))) - stack = stack_cons(stack, InterpretK(self._c_args[len(self._c_acc) + 1], self._c_locals)) + if len(self._c_acc) + 1 < self._c_args_ast.arg_count(): + stack = stack_cons(stack, ResolveAllK(self._c_args_ast, self._c_locals, self.append_to_acc(val))) + stack = stack_cons(stack, InterpretK(self._c_args_ast.get_arg(len(self._c_acc) + 1), self._c_locals)) else: - return Array(self.append_to_acc(val)), stack + return Args(self.append_to_acc(val)), stack return nil, stack def get_ast(self): - return self._c_args[len(self._c_acc)] + return self._c_args_ast.get_arg(len(self._c_acc)) def describe(self): return ArrayMap([kw_type, kw_resolve_all, - kw_args, Array(self._c_args), + kw_args, self._c_args_ast, #kw_locals, Array(self._c_locals), kw_acc, Array(self._c_acc), - kw_ast, self._c_args[len(self._c_acc)]]) + kw_ast, self._c_args_ast.get_arg(len(self._c_acc))]) @as_var("pixie.ast.internal", "->Let") def new_let(names, bindings, body, meta): @@ -550,7 +576,7 @@ def new_vderef(in_ns, var_name, meta): @expose("_c_var") class VDeref(AST): - _immutable_fields_ = ["_c_in_ns", "_c_var_name"] + _immutable_fields_ = ["_c_in_ns", "_c_var_name", "_c_var_ns"] _type = Type(u"pixie.ast-internal.VDeref") def type(self): @@ -855,4 +881,3 @@ def invoke_k(self, args, stack): return result as_var("pixie.ast.internal", "eval")(EvalFn()) - From 8a688d4f6fc01ea845c659ae0575334d85a18112 Mon Sep 17 00:00:00 2001 From: Timothy Baldridge Date: Thu, 23 Jul 2015 17:05:38 -0600 Subject: [PATCH 46/46] more jit tweaks --- pixie/bootstrap.pxi | 2 +- pixie/main.pxi | 9 +++---- pixie/vm2/array.py | 10 ++++++++ pixie/vm2/code.py | 13 +++++++++- pixie/vm2/interpreter.py | 55 +++++++++++++++++++++++++++++++--------- pixie/vm2/object.py | 1 - 6 files changed, 70 insertions(+), 20 deletions(-) diff --git a/pixie/bootstrap.pxi b/pixie/bootstrap.pxi index 65e10425..9552874c 100644 --- a/pixie/bootstrap.pxi +++ b/pixie/bootstrap.pxi @@ -1570,7 +1570,7 @@ not enough elements were present." (+ idx 2))) acc)))))) -(defn array-copy [from from-idx to to-idx size] +#_(defn array-copy [from from-idx to to-idx size] (loop [idx 0] (when (< idx size) (do (aset to (+ to-idx idx) (aget from (+ from-idx idx))) diff --git a/pixie/main.pxi b/pixie/main.pxi index eb6d3598..82958500 100644 --- a/pixie/main.pxi +++ b/pixie/main.pxi @@ -58,16 +58,13 @@ (with-handler [_ dynamic-var-handler] (binding [reader/*current-ns* 'user] (loop [] - (println "READING FORM") - (let [d (reader/read rdr false) - _ (println "Compiling " d)] + (let [d (reader/read rdr false)] (if (not (= d :eof)) (let [analyzed (ast-out/to-ast (compiler/analyze d))] - (println "GOT " d) (pixie.ast.internal/eval analyzed) (recur))))))))) -#_(try +(try (load-file :pixie.ffi-infer) (catch :* data (println "ERROR Compiling file" data) @@ -115,3 +112,5 @@ (repl) (println "done") + +((fn [x] (if (< x 1000) (recur (inc x)))) 0) diff --git a/pixie/vm2/array.py b/pixie/vm2/array.py index 95ad9f71..9647ec3c 100644 --- a/pixie/vm2/array.py +++ b/pixie/vm2/array.py @@ -160,6 +160,16 @@ def aset(self, idx, val): self._list[idx.int_val()] = val return val +@as_var("array-copy") +def array_copy(afrom, afstart, ato, atstart, cnt): + afrom = afrom.array_val() + ato = ato.array_val() + afstart = afstart.int_val() + atstart = atstart.int_val() + for x in range(cnt.int_val()): + ato[atstart + x] = afrom[afstart + x] + + # # @as_var("aslice") # def aslice(self, offset): diff --git a/pixie/vm2/code.py b/pixie/vm2/code.py index 5c56a142..a6490ebb 100644 --- a/pixie/vm2/code.py +++ b/pixie/vm2/code.py @@ -418,7 +418,7 @@ def set_var_value(self, var, val): class Var(BaseCode): _type = object.Type(u"pixie.stdlib.Var") - _immutable_fields_ = ["_rev?"] + _immutable_fields_ = ["_rev?", "_ns", "_name"] def type(self): return Var._type @@ -974,6 +974,17 @@ def wrapped_fn(self, args): raise return as_native_fn(wrapped_fn) + if argc == 5: + def wrapped_fn(self, args): + affirm(len(args) == 5, u"Expected 5 arguments to " + fn_name) + + try: + return rt.wrap(fn(args[0], args[1], args[2], args[3], args[4])) + except object.WrappedException as ex: + #ex._ex._trace.append(object.NativeCodeInfo(fn_name)) + raise + return as_native_fn(wrapped_fn) + assert False, "implement more" diff --git a/pixie/vm2/interpreter.py b/pixie/vm2/interpreter.py index e7327135..a6c274ef 100644 --- a/pixie/vm2/interpreter.py +++ b/pixie/vm2/interpreter.py @@ -8,6 +8,7 @@ from pixie.vm2.code import BaseCode import pixie.vm2.rt as rt import rpython.rlib.jit as jit +import rpython.rlib.debug as debug from pixie.vm2.debugger import expose kw_type = keyword(u"type") @@ -35,9 +36,9 @@ def type(self): return Args._type def __init__(self, lst): - self._c_list = lst + self._c_list = debug.make_sure_not_resized(lst) - def c_array_value(self): + def c_array_val(self): return self._c_list @@ -126,7 +127,6 @@ def get_ast(self): @as_var("pixie.ast.internal", "->Const") def new_const(val, meta): - print val, meta return Const(val, meta) @expose("_c_val") @@ -245,7 +245,7 @@ def interpret(self, _, locals, stack): return InterpretedFn(self._c_name, self._c_args, locals_prefix, self._c_body, self), stack class InterpretedFn(code.BaseCode): - _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name", "_c_arg_names", "_c_fn_def_ast"] + _immutable_fields_ = ["_c_arg_names[*]", "_c_locals", "_c_fn_ast", "_c_name", "_c_fn_def_ast"] _type = Type(u"pixie.stdlib.InterpretedFn") def type(self): @@ -291,7 +291,7 @@ def invoke_k_with(self, args, stack, self_fn): for idx in range(len(self._c_arg_names)): locals = Locals(self._c_arg_names[idx], args[idx], locals) - return nil, stack_cons(stack, InterpretK(self._c_fn_ast, locals)) + return nil, stack_cons(stack, InterpretK(jit.promote(self._c_fn_ast), locals)) @as_var("pixie.ast.internal", "->Invoke") @@ -376,6 +376,15 @@ def __init__(self, ast): def get_ast(self): return self._c_ast + @jit.unroll_safe + def recur(self, args, stack): + fn = args.get_arg(0) + new_args = [None] * (args.get_arg_count() - 1) + for x in range(args.get_arg_count() - 1): + new_args[x] = args.get_arg(x + 1) + + return fn.invoke_k(new_args, stack) + class ResolveAllK(Continuation): _immutable_ = True def __init__(self, args, locals, acc): @@ -522,7 +531,7 @@ def new_do(args, meta): return Do(args.array_val(), meta) class Do(AST): - _immutable_fields_ = ["_c_body_asts"] + _immutable_fields_ = ["_c_body_asts[*]"] _type = Type(u"pixie.ast-internal.Do") def type(self): @@ -661,7 +670,22 @@ def gather_locals(self): def get_printable_location(ast): return ast.get_short_location() -jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "cont"], get_printable_location=get_printable_location) +class VirtArgs(object): + _virtualizable_ = ["_args[*]"] + def __init__(self, args): + self = jit.hint(self, access_directly=True, fresh_virtualizable=True) + self._args = debug.make_sure_not_resized(args) + + def get_arg_count(self): + return len(self._args) + + def get_arg(self, idx): + assert 0 <= idx < len(self._args) + return self._args[idx] + +jitdriver = JitDriver(greens=["ast"], reds=["stack", "val", "args", "cont"], get_printable_location=get_printable_location, + virtualizables=["args"]) +jit.set_param(jitdriver, "trace_limit", 30000) throw_var = code.intern_var(u"pixie.stdlib", u"throw") @@ -669,16 +693,21 @@ def run_stack(val, cont, stack=None, enter_debug=True): stack = None val = None ast = cont.get_ast() + args = None while True: - jitdriver.jit_merge_point(ast=ast, stack=stack, val=val, cont=cont) + jitdriver.jit_merge_point(ast=ast, stack=stack, val=val, args=args, cont=cont) try: - val, stack = cont.call_continuation(val, stack) + if isinstance(cont, RecurK): + val, stack = cont.recur(args, stack) + args = None + else: + val, stack = cont.call_continuation(val, stack) ast = cont.get_ast() except SystemExit: raise except BaseException as ex: - if enter_debug: - from pixie.vm2.debugger import debug + #if enter_debug: + # from pixie.vm2.debugger import debug #debug(cont, stack, val) #print_stacktrace(cont, stack) if not we_are_translated(): @@ -696,7 +725,9 @@ def run_stack(val, cont, stack=None, enter_debug=True): break if isinstance(cont, RecurK): - jitdriver.can_enter_jit(ast=ast, stack=stack, val=val, cont=cont) + args = VirtArgs(val.c_array_val()) + val = None + jitdriver.can_enter_jit(ast=ast, stack=stack, val=val, args=args, cont=cont) return val diff --git a/pixie/vm2/object.py b/pixie/vm2/object.py index 419e9125..aa12f9a0 100644 --- a/pixie/vm2/object.py +++ b/pixie/vm2/object.py @@ -5,7 +5,6 @@ class Object(object): """ Base Object for all VM objects """ _attrs_ = () - def type(self): if not we_are_translated(): print "FOR TYPE", self