add is_subcalss_of, BREAKING: enhance moon.type() to remove weird class object behavior

Author: leafo

docs/standard_lib.md

@@ -160,24 +160,43 @@ inherits from `class`.
 class Parent
 class Child extends Parent
 
-is_instance_of Child!, Parent -- true
 is_instance_of Child!, Child  -- true
+is_instance_of Child!, Parent -- true (checks parent classes)
 is_instance_of Parent!, Child -- false
 ```
 
+To check if a value is a direct instance of a specific class without considering
+inheritance, use `type(value) == MyClass` instead.
+
+### `is_subclass_of(cls, parent)`
+
+Returns `true` if `cls` is a subclass of `parent`, `false` otherwise. Throws an
+error if `cls` is not a MoonScript class. Note that a class is not considered a
+subclass of itself. Walks the `__parent` chain starting from `cls` to check if
+any ancestor matches `parent`.
+
+```moon
+class Parent
+class Child extends Parent
+
+is_subclass_of Child, Parent -- true
+is_subclass_of Parent, Child -- false
+is_subclass_of Child, Child  -- false
+```
+
 ### `type(value)`
 
-If `value` is an instance of a MoonScript class, then return its class object.
-If `value` is a class table, return the class itself. Returns the result of
-calling Lua's built-in `type` for all other values, including `__base` tables
-and plain tables.
+Returns a class-aware type for a value. If `value` is an instance of a
+MoonScript class, returns its class object. If `value` is a class table, returns
+the string `"class"`. Returns the result of calling Lua's built-in `type` for
+all other values, including `__base` tables and plain tables.
 
 ```moon
 class MyClass
 
 x = MyClass!
 assert type(x) == MyClass
-assert type(MyClass) == MyClass
+assert type(MyClass) == "class"
 assert type(MyClass.__base) == "table"
 ```
 

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, is_instance_of, 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, is_subclass_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
@@ -45,9 +45,25 @@ is_instance_of = function(value, cls)
   end
   return false
 end
+is_subclass_of = function(cls, parent)
+  if not (is_class(cls)) then
+    error("is_subclass_of: expected class, got " .. tostring(lua.type(cls)))
+  end
+  local check = cls.__parent
+  while check do
+    if check == parent 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
+    if is_class(value) then
+      return "class"
+    end
     local cls = value.__class
     if cls and rawget(value, "__class") == nil then
       return cls
@@ -195,6 +211,7 @@ return {
   is_class = is_class,
   is_instance = is_instance,
   is_instance_of = is_instance_of,
+  is_subclass_of = is_subclass_of,
   type = type,
   debug = debug,
   run_with_scope = run_with_scope,

moon/init.moon

@@ -34,9 +34,20 @@ is_instance_of = (value, cls) ->
     check = check.__parent
   false
 
+is_subclass_of = (cls, parent) ->
+  error "is_subclass_of: expected class, got #{lua.type cls}" unless is_class cls
+  check = cls.__parent
+  while check
+    if check == parent
+      return true
+    check = check.__parent
+  false
+
 type = (value) -> -- class aware type
   base_type = lua.type value
   if base_type == "table"
+    if is_class value
+      return "class"
     cls = value.__class
     if cls and rawget(value, "__class") == nil
       return cls
@@ -153,6 +164,6 @@ fold = (items, fn)->
     items[1]
 
 {
-  :dump, :p, :is_object, :is_class, :is_instance, :is_instance_of, :type, :debug, :run_with_scope, :bind_methods,
+  :dump, :p, :is_object, :is_class, :is_instance, :is_instance_of, :is_subclass_of, :type, :debug, :run_with_scope, :bind_methods,
   :defaultbl, :extend, :copy, :mixin, :mixin_object, :mixin_table, :fold
 }

spec/moon_spec.moon

@@ -9,9 +9,9 @@ describe "moon", ->
     moon = require "moon"
 
   describe "type", ->
-    it "returns the class for a class", ->
+    it "returns 'class' for a class", ->
       class Test
-      assert.equal Test, moon.type Test
+      assert.equal "class", moon.type Test
 
     it "returns the class for an instance", ->
       class Test
@@ -38,6 +38,12 @@ describe "moon", ->
       assert.equal "table", moon.type {}
       assert.equal "table", moon.type {hello: "world"}
 
+    it "returns 'class' for classes with inheritance", ->
+      class Parent
+      class Child extends Parent
+      assert.equal "class", moon.type Parent
+      assert.equal "class", moon.type Child
+
     it "works with inheritance", ->
       class Parent
       class Child extends Parent
@@ -307,6 +313,60 @@ describe "moon", ->
       assert.falsy moon.is_instance_of A!, B
       assert.falsy moon.is_instance_of A!, C
 
+  describe "is_subclass_of", ->
+    it "returns true for direct child", ->
+      class Parent
+      class Child extends Parent
+      assert.truthy moon.is_subclass_of Child, Parent
+
+    it "returns true for deep inheritance", ->
+      class A
+      class B extends A
+      class C extends B
+      assert.truthy moon.is_subclass_of C, A
+      assert.truthy moon.is_subclass_of C, B
+      assert.truthy moon.is_subclass_of B, A
+
+    it "returns false for same class", ->
+      class A
+      assert.falsy moon.is_subclass_of A, A
+
+    it "returns false for parent checked against child", ->
+      class Parent
+      class Child extends Parent
+      assert.falsy moon.is_subclass_of Parent, Child
+
+    it "returns false for unrelated classes", ->
+      class A
+      class B
+      assert.falsy moon.is_subclass_of A, B
+      assert.falsy moon.is_subclass_of B, A
+
+    it "returns false for class without parent", ->
+      class A
+      class B
+      assert.falsy moon.is_subclass_of A, B
+
+    it "returns false when __base is passed as the parent", ->
+      class Parent
+      class Child extends Parent
+      assert.falsy moon.is_subclass_of Child, Parent.__base
+      assert.falsy moon.is_subclass_of Child, Child.__base
+
+    it "errors when first argument is not a class", ->
+      class Hello
+      assert.has_error (-> moon.is_subclass_of Hello!, Hello), "is_subclass_of: expected class, got table"
+      assert.has_error (-> moon.is_subclass_of Hello.__base, Hello), "is_subclass_of: expected class, got table"
+      assert.has_error (-> moon.is_subclass_of {}, Hello), "is_subclass_of: expected class, got table"
+      assert.has_error (-> moon.is_subclass_of nil, Hello), "is_subclass_of: expected class, got nil"
+      assert.has_error (-> moon.is_subclass_of 123, Hello), "is_subclass_of: expected class, got number"
+
+    it "errors when __base is passed as the first argument", ->
+      class Parent
+      class Child extends Parent
+      assert.has_error (-> moon.is_subclass_of Parent.__base, Parent), "is_subclass_of: expected class, got table"
+      assert.has_error (-> moon.is_subclass_of Child.__base, Child), "is_subclass_of: expected class, got table"
+
   it "should fold", ->
     numbers = {4,3,5,6,7,2,3}
     sum = moon.fold numbers, (a,b) -> a + b