Let satisfies? and instance? both take seqables as their first argument.

This time this is implemented in pixie code.

Author: truecolour

pixie/stdlib.pxi

@@ -164,6 +164,30 @@
 (def reduce (fn [rf init col]
               (-reduce col rf init)))
 
+(def instance? (fn ^{: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."}
+                 instance? [t x]
+                 (if (-satisfies? ISeqable t)
+                   (let [ts (seq t)]
+                     (if (not ts) false
+                       (or (-instance? (first ts) x)
+                           (instance? (rest ts) x))))
+                   (-instance? t x))))
+
+(def satisfies? (fn ^{:doc "Checks if x satisfies the protocol p.
+
+                            When p is seqable, checks if x satisfies all of
+                            the protocols contained therein."}
+                  satisfies? [p x]
+                  (if (-satisfies? ISeqable p)
+                    (let [ps (seq p)]
+                      (if (not ps) true
+                        (and (-satisfies? (first ps) x)
+                             (satisfies? (rest ps) x))))
+                    (-satisfies? p x))))
+
 (def into (fn ^{:doc "Add the elements of `from` to the collection `to`."
                 :signatures [[to from]]
                 :added "0.1"}

pixie/vm/compiler.py

@@ -353,7 +353,7 @@ def compile_form(form, ctx):
         ctx.push_const(nil)
         return
 
-    if rt.satisfies_QMARK_(rt.ISeq.deref(), form) and form is not nil:
+    if rt._satisfies_QMARK_(rt.ISeq.deref(), form) and form is not nil:
         form = macroexpand(form)
         return compile_cons(form, ctx)
     if isinstance(form, numbers.Integer):
@@ -425,7 +425,7 @@ def compile_form(form, ctx):
         compile_set_literal(form, ctx)
         return
 
-    if rt.satisfies_QMARK_(rt.IMap.deref(), form):
+    if rt._satisfies_QMARK_(rt.IMap.deref(), form):
         compile_map_literal(form, ctx)
         return
 
@@ -480,7 +480,7 @@ def compile_fn(form, ctx):
 
 
 
-    if rt.satisfies_QMARK_(rt.ISeq.deref(), rt.first(form)):
+    if rt._satisfies_QMARK_(rt.ISeq.deref(), rt.first(form)):
         arities = []
         while form is not nil:
             required_arity, argc = compile_fn_body(name, rt.first(rt.first(form)), rt.next(rt.first(form)), ctx)

pixie/vm/libs/pxic/writer.py

@@ -255,11 +255,11 @@ def write_object(obj, wtr):
     elif isinstance(obj, Var):
         #wtr.write_cached_obj(obj, write_var)
         write_var(obj, wtr)
-    elif rt.satisfies_QMARK_(rt.IMap.deref(), obj):
+    elif rt._satisfies_QMARK_(rt.IMap.deref(), obj):
         write_map(obj, wtr)
-    elif rt.satisfies_QMARK_(rt.IVector.deref(), obj):
+    elif rt._satisfies_QMARK_(rt.IVector.deref(), obj):
         write_vector(obj, wtr)
-    elif rt.satisfies_QMARK_(rt.ISeq.deref(), obj):
+    elif rt._satisfies_QMARK_(rt.ISeq.deref(), obj):
         write_seq(obj, wtr)
     elif isinstance(obj, Keyword):
         wtr.write_cached_obj(obj, write_keyword)

pixie/vm/persistent_vector.py

@@ -456,7 +456,7 @@ def _eq(self, obj):
                 return false
         return true
     else:
-        if obj is nil or not rt.satisfies_QMARK_(proto.ISeqable, obj):
+        if obj is nil or not rt._satisfies_QMARK_(proto.ISeqable, obj):
             return false
         seq = rt.seq(obj)
         for i in range(0, intmask(self._cnt)):

pixie/vm/reader.py

@@ -449,12 +449,12 @@ def invoke(self, rdr, ch):
 LIST = symbol(u"list")
 
 def is_unquote(form):
-    return True if rt.satisfies_QMARK_(rt.ISeq.deref(), form) \
+    return True if rt._satisfies_QMARK_(rt.ISeq.deref(), form) \
                    and rt.eq(rt.first(form), UNQUOTE) \
            else False
 
 def is_unquote_splicing(form):
-    return True if rt.satisfies_QMARK_(rt.ISeq.deref(), form) \
+    return True if rt._satisfies_QMARK_(rt.ISeq.deref(), form) \
                    and rt.eq(rt.first(form), UNQUOTE_SPLICING) \
            else False
 
@@ -537,7 +537,7 @@ def invoke(self, rdr, ch):
         if isinstance(meta, Symbol):
             meta = rt.hashmap(keyword(u"tag"), meta)
 
-        if rt.satisfies_QMARK_(rt.IMeta.deref(), obj):
+        if rt._satisfies_QMARK_(rt.IMeta.deref(), obj):
             return rt.with_meta(obj, rt.merge(meta, rt.meta(obj)))
 
         return obj

pixie/vm/stdlib.py

@@ -121,7 +121,7 @@ def default_hash(x):
 
 @as_var("first")
 def first(x):
-    if rt.satisfies_QMARK_(ISeq, x):
+    if rt._satisfies_QMARK_(ISeq, x):
         return rt._first(x)
 
     seq = rt.seq(x)
@@ -131,7 +131,7 @@ def first(x):
 
 @as_var("next")
 def next(x):
-    if rt.satisfies_QMARK_(ISeq, x):
+    if rt._satisfies_QMARK_(ISeq, x):
         return rt.seq(rt._next(x))
     seq = rt.seq(x)
     if seq is nil:
@@ -145,15 +145,15 @@ def seq(x):
 
 @as_var("seq?")
 def seq_QMARK_(x):
-    return true if rt.satisfies_QMARK_(rt.ISeq.deref(), x) else false
+    return true if rt._satisfies_QMARK_(rt.ISeq.deref(), x) else false
 
 @as_var("-seq-eq")
 def _seq_eq(a, b):
     if a is b:
         return true
     if a is nil or b is nil:
         return false
-    if not (rt.satisfies_QMARK_(rt.ISeqable.deref(), b) or rt.satisfies_QMARK_(rt.ISeq.deref(), b)):
+    if not (rt._satisfies_QMARK_(rt.ISeqable.deref(), b) or rt._satisfies_QMARK_(rt.ISeq.deref(), b)):
         return false
 
     a = rt.seq(a)
@@ -286,7 +286,7 @@ def __with_meta(a, b):
 @returns(bool)
 @as_var("has-meta?")
 def __has_meta(a):
-    return true if rt.satisfies_QMARK_(rt.IMeta.deref(), a) else false
+    return true if rt._satisfies_QMARK_(rt.IMeta.deref(), a) else false
 
 @as_var("conj")
 def conj(a, b):
@@ -313,8 +313,8 @@ def str__args(args):
 @jit.unroll_safe
 def apply__args(args):
     last_itm = args[len(args) - 1]
-    if not (rt.satisfies_QMARK_(rt.IIndexed.deref(), last_itm) and
-            rt.satisfies_QMARK_(rt.ICounted.deref(), last_itm)):
+    if not (rt._satisfies_QMARK_(rt.IIndexed.deref(), last_itm) and
+            rt._satisfies_QMARK_(rt.ICounted.deref(), last_itm)):
         last_itm = rt.vec(last_itm)
 
     fn = args[0]
@@ -335,14 +335,14 @@ def apply__args(args):
 #    return nil
 
 @returns(bool)
-@as_var("instance?")
+@as_var("-instance?")
 def _instance(c, o):
     affirm(isinstance(c, Type), u"c must be a type")
 
     return true if istypeinstance(o, c) else false
 
 @returns(bool)
-@as_var("satisfies?")
+@as_var("-satisfies?")
 def _satisfies(proto, o):
     affirm(isinstance(proto, Protocol), u"proto must be a Protocol")
 
@@ -625,7 +625,7 @@ def identical(a, b):
 
 @as_var("vector?")
 def vector_QMARK_(a):
-    return true if rt.satisfies_QMARK_(rt.IVector.deref(), a) else false
+    return true if rt._satisfies_QMARK_(rt.IVector.deref(), a) else false
 
 @returns(bool)
 @as_var("eq")