add is_instance and is_object to moon library

Author: leafo

docs/standard_lib.md

@@ -108,19 +108,52 @@ copy = (arg) -> {k,v for k,v in pairs self}
 
 ### `is_object(value)`
 
-Returns true if `value` is an instance of a MoonScript class, false otherwise.
+**Deprecated:** Use `is_instance` or `is_class` instead. `is_object` returns
+truthy for instances, classes, and `__base` tables — any table with `__class`
+accessible. It cannot distinguish between these cases.
+
+### `is_class(value)`
+
+Returns `true` if `value` is a MoonScript class table, `false` otherwise.
+Returns `false` for instances, `__base` tables, plain tables, and non-table
+values.
+
+```moon
+class MyClass
+
+is_class MyClass        -- true
+is_class MyClass!       -- false
+is_class MyClass.__base -- false
+```
+
+### `is_instance(value)`
+
+Returns `true` if `value` is an instance of a MoonScript class, `false`
+otherwise. Returns `false` for class tables, `__base` tables, plain tables, and
+non-table values.
+
+```moon
+class MyClass
+
+is_instance MyClass!       -- true
+is_instance MyClass        -- false
+is_instance MyClass.__base -- false
+```
 
 ### `type(value)`
 
-If `value` is an instance of a MoonScript class, then return it's class object.
-Otherwise, return the result of calling Lua's type method.
+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.
 
 ```moon
 class MyClass
-  nil
 
 x = MyClass!
 assert type(x) == MyClass
+assert type(MyClass) == MyClass
+assert type(MyClass.__base) == "table"
 ```
 
 ### `bind_methods(obj)`

moon/init.lua

@@ -7,21 +7,31 @@ do
   local _obj_0 = require("moonscript.util")
   getfenv, setfenv, dump = _obj_0.getfenv, _obj_0.setfenv, _obj_0.dump
 end
-local p, is_object, type, debug, run_with_scope, bind_methods, defaultbl, extend, copy, mixin, mixin_object, mixin_table, fold
+local p, is_object, is_class, is_instance, 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
     return p(...)
   end
 end
-is_object = function(value)
+is_object = function(value) -- deprecated: use is_instance or is_class instead
   return lua.type(value) == "table" and value.__class
 end
+is_class = function(value)
+  return lua.type(value) == "table" and rawget(value, "__base") ~= nil
+end
+is_instance = function(value)
+  if lua.type(value) == "table" then
+    local mt = getmetatable(value)
+    return mt and rawget(mt, "__class") ~= nil
+  end
+  return false
+end
 type = function(value)
   local base_type = lua.type(value)
   if base_type == "table" then
     local cls = value.__class
-    if cls then
+    if cls and rawget(value, "__class") == nil then
       return cls
     end
   end
@@ -164,6 +174,8 @@ return {
   dump = dump,
   p = p,
   is_object = is_object,
+  is_class = is_class,
+  is_instance = is_instance,
   type = type,
   debug = debug,
   run_with_scope = run_with_scope,

moon/init.moon

@@ -9,14 +9,24 @@ p = (o, ...) ->
   if select("#", ...) > 0
     p ...
 
-is_object =  (value) -> -- is a moonscript object
+is_object =  (value) -> -- deprecated: use is_instance or is_class instead
   lua.type(value) == "table" and value.__class
 
+is_class = (value) ->
+  lua.type(value) == "table" and rawget(value, "__base") != nil
+
+is_instance = (value) ->
+  if lua.type(value) == "table"
+    mt = getmetatable value
+    return mt and rawget(mt, "__class") != nil
+  false
+
 type = (value) -> -- class aware type
   base_type = lua.type value
   if base_type == "table"
     cls = value.__class
-    return cls if cls
+    if cls and rawget(value, "__class") == nil
+      return cls
   base_type
 
 debug = setmetatable {
@@ -130,6 +140,6 @@ fold = (items, fn)->
     items[1]
 
 {
-  :dump, :p, :is_object, :type, :debug, :run_with_scope, :bind_methods,
+  :dump, :p, :is_object, :is_class, :is_instance, :type, :debug, :run_with_scope, :bind_methods,
   :defaultbl, :extend, :copy, :mixin, :mixin_object, :mixin_table, :fold
 }

moonscript/util.lua

@@ -3,8 +3,15 @@ concat = table.concat
 local unpack = unpack or table.unpack
 local type = type
 local moon = {
-  is_object = function(value)
-    return type(value) == "table" and value.__class
+  is_class = function(value)
+    return type(value) == "table" and rawget(value, "__base") ~= nil
+  end,
+  is_instance = function(value)
+    if type(value) == "table" then
+      local mt = getmetatable(value)
+      return mt and rawget(mt, "__class") ~= nil
+    end
+    return false
   end,
   is_a = function(thing, t)
     if not (type(thing) == "table") then
@@ -23,7 +30,7 @@ local moon = {
     local base_type = type(value)
     if base_type == "table" then
       local cls = value.__class
-      if cls then
+      if cls and rawget(value, "__class") == nil then
         return cls
       end
     end

moonscript/util.moon

@@ -4,9 +4,15 @@ import concat from table
 unpack = unpack or table.unpack
 type = type
 
-moon =
-  is_object: (value) -> -- is a moonscript object
-    type(value) == "table" and value.__class
+moon = {
+  is_class: (value) ->
+    type(value) == "table" and rawget(value, "__base") != nil
+
+  is_instance: (value) ->
+    if type(value) == "table"
+      mt = getmetatable value
+      return mt and rawget(mt, "__class") != nil
+    false
 
   is_a: (thing, t) ->
     return false unless type(thing) == "table"
@@ -22,8 +28,10 @@ moon =
     base_type = type value
     if base_type == "table"
       cls = value.__class
-      return cls if cls
+      if cls and rawget(value, "__class") == nil
+        return cls
     base_type
+}
 
 -- convet position in text to line number
 pos_to_line = (str, pos) ->

spec/moon_spec.moon

@@ -8,15 +8,37 @@ describe "moon", ->
   with_dev ->
     moon = require "moon"
 
-  it "should determine correct type", ->
-    class Test
-
-    things = {
-      Test, Test!, 1, true, nil, "hello"
-    }
-
-    types = [moon.type t for t in *things]
-    assert.same types, { Test, Test, "number", "boolean", "nil", "string" }
+  describe "type", ->
+    it "returns the class for a class", ->
+      class Test
+      assert.equal Test, moon.type Test
+
+    it "returns the class for an instance", ->
+      class Test
+      assert.equal Test, moon.type Test!
+
+    it "returns 'table' for __base", ->
+      class Test
+      assert.equal "table", moon.type Test.__base
+
+    it "returns primitive type for non-tables", ->
+      assert.equal "number", moon.type 1
+      assert.equal "boolean", moon.type true
+      assert.equal "nil", moon.type nil
+      assert.equal "string", moon.type "hello"
+      assert.equal "function", moon.type ->
+
+    it "returns 'table' for plain tables", ->
+      assert.equal "table", moon.type {}
+      assert.equal "table", moon.type {hello: "world"}
+
+    it "works with inheritance", ->
+      class Parent
+      class Child extends Parent
+      assert.equal Child, moon.type Child!
+      assert.equal Parent, moon.type Parent!
+      assert.equal "table", moon.type Child.__base
+      assert.equal "table", moon.type Parent.__base
 
   it "should get upvalue", ->
     fn = do
@@ -114,6 +136,61 @@ describe "moon", ->
 
     assert.same a, { hello: "world", cat: "mouse", foo: "bar"}
 
+  describe "is_class", ->
+    it "returns true for a class", ->
+      class Hello
+      assert.truthy moon.is_class Hello
+
+    it "returns false for an instance", ->
+      class Hello
+      assert.falsy moon.is_class Hello!
+
+    it "returns false for __base", ->
+      class Hello
+      assert.falsy moon.is_class Hello.__base
+
+    it "returns false for plain tables and non-tables", ->
+      assert.falsy moon.is_class {}
+      assert.falsy moon.is_class 123
+      assert.falsy moon.is_class "hello"
+      assert.falsy moon.is_class nil
+      assert.falsy moon.is_class true
+
+    it "works with inheritance", ->
+      class Parent
+      class Child extends Parent
+      assert.truthy moon.is_class Parent
+      assert.truthy moon.is_class Child
+      assert.falsy moon.is_class Child!
+
+  describe "is_instance", ->
+    it "returns true for an instance", ->
+      class Hello
+      assert.truthy moon.is_instance Hello!
+
+    it "returns false for a class", ->
+      class Hello
+      assert.falsy moon.is_instance Hello
+
+    it "returns false for __base", ->
+      class Hello
+      assert.falsy moon.is_instance Hello.__base
+
+    it "returns false for plain tables and non-tables", ->
+      assert.falsy moon.is_instance {}
+      assert.falsy moon.is_instance 123
+      assert.falsy moon.is_instance "hello"
+      assert.falsy moon.is_instance nil
+      assert.falsy moon.is_instance true
+
+    it "works with inheritance", ->
+      class Parent
+      class Child extends Parent
+      assert.truthy moon.is_instance Parent!
+      assert.truthy moon.is_instance Child!
+      assert.falsy moon.is_instance Parent
+      assert.falsy moon.is_instance Child
+
   it "should fold", ->
     numbers = {4,3,5,6,7,2,3}
     sum = moon.fold numbers, (a,b) -> a + b