add is_instance_of public function

Author: leafo

docs/standard_lib.md

@@ -148,6 +148,23 @@ is_instance MyClass        -- false
 is_instance MyClass.__base -- false
 ```
 
+### `is_instance_of(value, class)`
+
+Returns `true` if `value` is an instance of `class` or any of its parent
+classes, `false` otherwise. Throws an error if `value` is not a MoonScript
+instance. First verifies that `value` is a valid instance using `is_instance`,
+then walks the `__parent` chain to check if the instance's class matches or
+inherits from `class`.
+
+```moon
+class Parent
+class Child extends Parent
+
+is_instance_of Child!, Parent -- true
+is_instance_of Child!, Child  -- true
+is_instance_of Parent!, Child -- false
+```
+
 ### `type(value)`
 
 If `value` is an instance of a MoonScript class, then return its class object.

moon/init.lua

@@ -7,7 +7,7 @@ do
   local _obj_0 = require("moonscript.util")
   getfenv, setfenv, dump = _obj_0.getfenv, _obj_0.setfenv, _obj_0.dump
 end
-local p, is_object, is_class, is_instance, type, debug, run_with_scope, bind_methods, defaultbl, extend, copy, mixin, mixin_object, mixin_table, fold
+local p, is_object, is_class, is_instance, is_instance_of, type, debug, run_with_scope, bind_methods, defaultbl, extend, copy, mixin, mixin_object, mixin_table, fold
 p = function(o, ...)
   print(dump(o))
   if select("#", ...) > 0 then
@@ -31,6 +31,20 @@ is_instance = function(value)
   end
   return false
 end
+is_instance_of = function(value, cls)
+  if not (is_instance(value)) then
+    error("is_instance_of: expected instance, got " .. tostring(lua.type(value)))
+  end
+  local mt = getmetatable(value)
+  local check = rawget(mt, "__class")
+  while check do
+    if check == cls then
+      return true
+    end
+    check = check.__parent
+  end
+  return false
+end
 type = function(value)
   local base_type = lua.type(value)
   if base_type == "table" then
@@ -180,6 +194,7 @@ return {
   is_object = is_object,
   is_class = is_class,
   is_instance = is_instance,
+  is_instance_of = is_instance_of,
   type = type,
   debug = debug,
   run_with_scope = run_with_scope,

moon/init.moon

@@ -24,6 +24,16 @@ is_instance = (value) ->
     return mt and rawget(mt, "__index") == mt and rawget(value, "__index") != value
   false
 
+is_instance_of = (value, cls) ->
+  error "is_instance_of: expected instance, got #{lua.type value}" unless is_instance value
+  mt = getmetatable value
+  check = rawget mt, "__class"
+  while check
+    if check == cls
+      return true
+    check = check.__parent
+  false
+
 type = (value) -> -- class aware type
   base_type = lua.type value
   if base_type == "table"
@@ -143,6 +153,6 @@ fold = (items, fn)->
     items[1]
 
 {
-  :dump, :p, :is_object, :is_class, :is_instance, :type, :debug, :run_with_scope, :bind_methods,
+  :dump, :p, :is_object, :is_class, :is_instance, :is_instance_of, :type, :debug, :run_with_scope, :bind_methods,
   :defaultbl, :extend, :copy, :mixin, :mixin_object, :mixin_table, :fold
 }

moonscript/util.lua

@@ -17,19 +17,6 @@ local moon = {
     end
     return false
   end,
-  is_a = function(thing, t)
-    if not (type(thing) == "table") then
-      return false
-    end
-    local cls = thing.__class
-    while cls do
-      if cls == t then
-        return true
-      end
-      cls = cls.__parent
-    end
-    return false
-  end,
   type = function(value)
     local base_type = type(value)
     if base_type == "table" then

moonscript/util.moon

@@ -17,16 +17,6 @@ moon = {
       return mt and rawget(mt, "__index") == mt and rawget(value, "__index") != value
     false
 
-  is_a: (thing, t) ->
-    return false unless type(thing) == "table"
-    cls = thing.__class
-    while cls
-      if cls == t
-        return true
-      cls = cls.__parent
-
-    false
-
   type: (value) -> -- the moonscript object class
     base_type = type value
     if base_type == "table"

spec/moon_spec.moon

@@ -245,6 +245,68 @@ describe "moon", ->
       assert.falsy moon.is_instance Parent
       assert.falsy moon.is_instance Child
 
+  describe "is_instance_of", ->
+    it "returns true for direct instance", ->
+      class Hello
+      assert.truthy moon.is_instance_of Hello!, Hello
+
+    it "returns true for instance of parent class", ->
+      class Parent
+      class Child extends Parent
+      assert.truthy moon.is_instance_of Child!, Parent
+      assert.truthy moon.is_instance_of Child!, Child
+
+    it "returns false for instance of unrelated class", ->
+      class A
+      class B
+      assert.falsy moon.is_instance_of A!, B
+      assert.falsy moon.is_instance_of B!, A
+
+    it "returns false for parent instance checked against child class", ->
+      class Parent
+      class Child extends Parent
+      assert.falsy moon.is_instance_of Parent!, Child
+
+    it "errors when value is not an instance", ->
+      class Hello
+      assert.has_error (-> moon.is_instance_of Hello, Hello), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of Hello.__base, Hello), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of {}, Hello), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of nil, Hello), "is_instance_of: expected instance, got nil"
+      assert.has_error (-> moon.is_instance_of 123, Hello), "is_instance_of: expected instance, got number"
+
+    it "errors when __base is passed as the value", ->
+      class Parent
+      class Child extends Parent
+      assert.has_error (-> moon.is_instance_of Parent.__base, Parent), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of Child.__base, Child), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of Child.__base, Parent), "is_instance_of: expected instance, got table"
+
+    it "returns false when __base is passed as the class", ->
+      class Parent
+      class Child extends Parent
+      assert.falsy moon.is_instance_of Parent!, Parent.__base
+      assert.falsy moon.is_instance_of Child!, Child.__base
+      assert.falsy moon.is_instance_of Child!, Parent.__base
+
+    it "errors when __base is on both sides", ->
+      class Parent
+      class Child extends Parent
+      assert.has_error (-> moon.is_instance_of Parent.__base, Parent.__base), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of Child.__base, Child.__base), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of Child.__base, Parent.__base), "is_instance_of: expected instance, got table"
+      assert.has_error (-> moon.is_instance_of Parent.__base, Child.__base), "is_instance_of: expected instance, got table"
+
+    it "works with deep inheritance chain", ->
+      class A
+      class B extends A
+      class C extends B
+      assert.truthy moon.is_instance_of C!, A
+      assert.truthy moon.is_instance_of C!, B
+      assert.truthy moon.is_instance_of C!, C
+      assert.falsy moon.is_instance_of A!, B
+      assert.falsy moon.is_instance_of A!, C
+
   it "should fold", ->
     numbers = {4,3,5,6,7,2,3}
     sum = moon.fold numbers, (a,b) -> a + b