Merge pull request #251 from pixie-lang/fix-bad-loops

optimizations for lazy seqs, partial, and immutable_fields

Author: halgari

pixie/stdlib.pxi

@@ -231,16 +231,17 @@
                                (seq (next coll)))
                         init)))))
 
-(def indexed-reduce (fn indexed-reduce
-                      [coll f init]
-                      (let [max (count coll)]
-                      (loop [init init
-                             i 0]
-                        (if (reduced? init)
-                          @init
-                          (if (-eq i max)
-                            init
-                            (recur (f init (nth coll i nil)) (+ i 1))))))))
+(def indexed-reduce
+  (fn indexed-reduce
+    [coll f init]
+    (let [max (count coll)]
+      (loop [init init
+             i 0]
+        (if (reduced? init)
+          @init
+          (if (-eq i max)
+            init
+            (recur (f init (nth coll i nil)) (+ i 1))))))))
 
 (def rest (fn ^{:doc "Returns the elements after the first element, or () if there are no more elements."
                 :signatures [[coll]]
@@ -2148,10 +2149,6 @@ Expands to calls to `extend-type`."
               names)
        result#)))
 
-(defn partial [f & args]
-  (fn [& args2]
-    (apply f (-> args vec (into args2)))))
-
 (defn pst
   {:doc "Prints the trace of a Runtime Exception if given, or the last Runtime Exception in *e"
    :signatures [[] [e]]

pixie/vm/array.py

@@ -13,7 +13,7 @@
 
 class Array(object.Object):
     _type = object.Type(u"pixie.stdlib.Array")
-    __immutable_fields__ = ["_list[*]"]
+    _immutable_fields_ = ["_list"]
     def type(self):
         return Array._type
 
@@ -76,7 +76,7 @@ def _seq(self):
 
 class ArraySeq(object.Object):
     _type = object.Type(u"pixie.stdlib.ArraySeq")
-    __immutable_fields__ = ["_idx", "_w_array"]
+    _immutable_fields_ = ["_idx", "_w_array"]
 
     def __init__(self, idx, array):
         self._idx = idx

pixie/vm/code.py

@@ -91,6 +91,7 @@ def slice_from_start(from_list, count, extra=r_uint(0)):
 
 
 class BaseCode(object.Object):
+    _immutable_fields_ = ["_meta"]
     def __init__(self):
         assert isinstance(self, BaseCode)
         self._name = u"unknown"
@@ -213,7 +214,7 @@ def invoke_with(self, args, this_fn):
 class Code(BaseCode):
     """Interpreted code block. Contains consts and """
     _type = object.Type(u"pixie.stdlib.Code")
-    __immutable_fields__ = ["_arity", "_consts[*]", "_bytecode", "_stack_size", "_meta"]
+    _immutable_fields_ = ["_arity", "_consts[*]", "_bytecode", "_stack_size", "_meta"]
 
     def type(self):
         return Code._type
@@ -271,7 +272,7 @@ def get_base_code(self):
 
 
 class VariadicCode(BaseCode):
-    __immutable_fields__ = ["_required_arity", "_code", "_meta"]
+    _immutable_fields_ = ["_required_arity", "_code", "_meta"]
     _type = object.Type(u"pixie.stdlib.VariadicCode")
 
     def type(self):
@@ -314,7 +315,7 @@ def invoke_with(self, args, self_fn):
 
 class Closure(BaseCode):
     _type = object.Type(u"pixie.stdlib.Closure")
-    __immutable_fields__ = ["_closed_overs[*]", "_code", "_meta"]
+    _immutable_fields_ = ["_closed_overs[*]", "_code", "_meta"]
 
     def type(self):
         return Closure._type
@@ -632,7 +633,7 @@ def invoke(self, args):
 class Protocol(object.Object):
     _type = object.Type(u"pixie.stdlib.Protocol")
 
-    __immutable_fields__ = ["_rev?"]
+    _immutable_fields_ = ["_rev?"]
 
     def type(self):
         return Protocol._type
@@ -664,7 +665,7 @@ class PolymorphicFn(BaseCode):
     def type(self):
         return PolymorphicFn._type
 
-    __immutable_fields__ = ["_rev?"]
+    _immutable_fields_ = ["_rev?"]
 
     def __init__(self, name, protocol):
         BaseCode.__init__(self)
@@ -738,7 +739,7 @@ class DoublePolymorphicFn(BaseCode):
     def type(self):
         return DefaultProtocolFn._type
 
-    __immutable_fields__ = ["_rev?"]
+    _immutable_fields_ = ["_rev?"]
 
     def __init__(self, name, protocol):
         BaseCode.__init__(self)

pixie/vm/custom_types.py

@@ -6,7 +6,7 @@
 import pixie.vm.rt as rt
 
 class CustomType(Type):
-    __immutable_fields__ = ["_slots", "_rev?"]
+    _immutable_fields_ = ["_slots", "_rev?"]
     def __init__(self, name, slots):
         Type.__init__(self, name)
 
@@ -36,7 +36,7 @@ def get_num_slots(self):
         return len(self._slots)
 
 class CustomTypeInstance(Object):
-    __immutable_fields__ = ["_type"]
+    _immutable_fields_ = ["_type"]
     def __init__(self, type, fields):
         affirm(isinstance(type, CustomType), u"Can't create a instance of a non custom type")
         self._custom_type = type

pixie/vm/keyword.py

@@ -10,7 +10,6 @@
 
 class Keyword(Object):
     _type = Type(u"pixie.stdlib.Keyword")
-    __immutable_fields__ = ["_hash"]
     def __init__(self, name):
         self._str = name
         self._w_name = None

pixie/vm/lazy_seq.py

@@ -3,6 +3,7 @@
 import pixie.vm.stdlib as proto
 from  pixie.vm.code import extend, as_var
 import pixie.vm.rt as rt
+import rpython.rlib.jit as jit
 
 
 class LazySeq(object.Object):
@@ -16,6 +17,7 @@ def __init__(self, fn, meta=nil):
         self._meta = meta
         self._s = nil
 
+    @jit.jit_callback("lazy_seq_sval")
     def sval(self):
         if self._fn is None:
             return self._s
@@ -24,6 +26,21 @@ def sval(self):
             self._fn = None
             return self._s
 
+    @jit.dont_look_inside
+    def lazy_seq_seq(self):
+        self.sval()
+        if self._s is not nil:
+            ls = self._s
+            while True:
+                if isinstance(ls, LazySeq):
+                    ls = ls.sval()
+                    continue
+                else:
+                    self._s = ls
+                    return rt.seq(self._s)
+        else:
+            return nil
+
 
 
 @extend(proto._first, LazySeq)
@@ -41,18 +58,8 @@ def _next(self):
 @extend(proto._seq, LazySeq)
 def _seq(self):
     assert isinstance(self, LazySeq)
-    self.sval()
-    if self._s is not nil:
-        ls = self._s
-        while True:
-            if isinstance(ls, LazySeq):
-                ls = ls.sval()
-                continue
-            else:
-                self._s = ls
-                return rt.seq(self._s)
-    else:
-        return nil
+    return self.lazy_seq_seq()
+
 
 @as_var("lazy-seq*")
 def lazy_seq(f):

pixie/vm/stdlib.py

@@ -814,6 +814,44 @@ def _doc(self):
     return rt.wrap(self._doc)
 
 
+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(self, args):
+        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(new_args)
+
+
+@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)
+
 @as_var("-get-current-var-frames")
 def _get_current_var_frames(self):
     """(-get-current-var-frames)
@@ -826,3 +864,4 @@ def _set_current_var_frames(self, frames):
        Sets the current var frames. Frames should be a cons list of hashmaps containing mappings of vars to dynamic
        values. Setting this value to anything but this data format will cause undefined errors."""
     code._dynamic_vars.set_current_frames(frames)
+

pixie/vm/symbol.py

@@ -10,8 +10,6 @@
 
 class Symbol(object.Object):
     _type = object.Type(u"pixie.stdlib.Symbol")
-    __immutable_fields__ = ["_hash"]
-
     def __init__(self, s, meta=nil):
         #assert isinstance(s, unicode)
         self._str = s