Update to KtLox v1.1.0

Author: HallofFamer

README.md

@@ -23,22 +23,25 @@ https://github.com/munificent/craftinginterpreters
 - Inheritance and this/super keywords
 - Metaclasses(challenge from the book)
 - Traits(challenge from the book)
+- Framework for creating native functions/classes(since v1.1.0)
 
 ## Roadmap
 
 ### KtLox v1.1.0(current version)
 - Improved object model - Everything is an object, including nil, true, false, number, string, etc.
 - Framework for writing Native functions and classes.
-- root class Object which serves as superclass of every class.
+- Root class Object which serves as superclass of every class.
+- Remove print statement and replace it by print/println native functions.
 
 ### KtLox v1.2.0(next version)
 - Full Fledged Standard Library: Boolean, Number, String, Array, Dictionary, DateTime, etc.
 - Mechanism for efficiently loading standard library at interpreter startup.
-- (maybe) Split the Number class, which will distinguish between integers and floating numbers.
+- Split the Number class, which will distinguish between integers and floating numbers.
 
 ### KtLox v1.3.0
 - Syntactic Sugar for Array/Dictionary Literals.
-- Short closures/lambda expression.
+- Short closures/lambda expression with nonlocal returns.
+- Replace C style for loop by Kotlin style for-in loop for collection.
 - (maybe) Null-safe operator (?.).
 
 ### KtLox v1.4.0
@@ -50,6 +53,7 @@ https://github.com/munificent/craftinginterpreters
 - Refinement of metaclass system to match smalltalk's metaobject protocol.
 - Improvement of trait system in KtLox.
 - Add some Metaclasses and traits to the standard library.
+- (maybe) Add feature for anonymous class and trait.
 
 ### KtLox v1.6.0
 - Introduction of Namespace for KtLox's module system.
@@ -61,7 +65,7 @@ https://github.com/munificent/craftinginterpreters
 - Add class Exception as well as a few more exception subclasses to the standard library.
 - (maybe) Pattern Matching
 
-### Ktlox v1.8.0
+### KtLox v1.8.0
 - Operator Overloading: enable user defined classes to overload operators, these operators are treated as method calls.
 - Method interception when an undefined method call is invoked on an object/class, similar to Smalltalk's doesNotUnderstand: message.
 - (maybe) Semicolon inference that allows semicolons to be omitted when its obvious that the statement is finished at the end of the line.
@@ -74,4 +78,4 @@ https://github.com/munificent/craftinginterpreters
 ### KtLox v2.0.0
 - Optional static typing support for instance variables and function/method parameters.
 - (maybe) Type inference for immutable variables, as well as possible optimization for typed variables.
-- (maybe) Slot as refied variables, similar to Pharo Smalltalk and Self's implementation. 
+- (maybe) Slot as reified variables, similar to Pharo Smalltalk and Self's implementation. 

src/main/kotlin/Ast.kt

@@ -38,7 +38,6 @@ object Ast {
             "Function   : Token name, Expr.Function functionBody",
             "Expression : Expr expression",
             "If         : Expr condition, Stmt thenBranch, Stmt? elseBranch",
-            "Print      : Expr expression",
             "Return     : Token keyword, Expr? value",
             "Trait      : Token name, List<Expr.Variable> traits, List<Stmt.Function> methods",
             "Var        : Token name, Expr? initializer",

src/main/kotlin/ast/Stmt.kt

@@ -11,7 +11,6 @@ abstract class Stmt {
         fun visitFunctionStmt(stmt: Function) : R
         fun visitExpressionStmt(stmt: Expression) : R
         fun visitIfStmt(stmt: If) : R
-        fun visitPrintStmt(stmt: Print) : R
         fun visitReturnStmt(stmt: Return) : R
         fun visitTraitStmt(stmt: Trait) : R
         fun visitVarStmt(stmt: Var) : R
@@ -26,7 +25,7 @@ abstract class Stmt {
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitBreakStmt(this)
     }
 
-    data class Class(val name: Token, val superclass: Expr.Variable, val traits: List<Expr.Variable>, val methods: List<Function>, val classMethods: List<Function>) : Stmt(){
+    data class Class(val name: Token, val superclass: Expr.Variable, val traits: List<Expr.Variable>, val methods: List<Stmt.Function>, val classMethods: List<Stmt.Function>) : Stmt(){
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitClassStmt(this)
     }
 
@@ -42,15 +41,11 @@ abstract class Stmt {
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitIfStmt(this)
     }
 
-    data class Print(val expression: Expr) : Stmt(){
-        override fun <R> accept(visitor: Visitor<R>) = visitor.visitPrintStmt(this)
-    }
-
     data class Return(val keyword: Token, val value: Expr?) : Stmt(){
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitReturnStmt(this)
     }
 
-    data class Trait(val name: Token, val traits: List<Expr.Variable>, val methods: List<Function>) : Stmt(){
+    data class Trait(val name: Token, val traits: List<Expr.Variable>, val methods: List<Stmt.Function>) : Stmt(){
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitTraitStmt(this)
     }
 

src/main/kotlin/common/LoxClass.kt

@@ -5,7 +5,8 @@ import com.mysidia.ktlox.interpreter.Interpreter
 open class LoxClass(val name: String,
                     val superclass: LoxClass?,
                     val methods: MutableMap<String, LoxCallable>,
-                    metaclass: LoxClass?) : LoxObject(metaclass), LoxCallable{
+                    val traits: MutableList<LoxTrait>? = null,
+                    metaclass: LoxClass? = null) : LoxObject(metaclass), LoxCallable{
 
     private val initializer by lazy { findMethod("init") }
     override val arity get() = initializer?.arity ?: 0

src/main/kotlin/common/LoxClassClass.kt

@@ -5,13 +5,24 @@ import com.mysidia.ktlox.interpreter.Interpreter
 object LoxClassClass : LoxNativeClass("Class", LoxObjectClass, null) {
 
     init{
+        klass = this
         defineNativeMethod("getSuperclass", 0, this::getSuperclassDef)
+        defineNativeMethod("getTraits", 0, this::getTraitsDef)
         defineNativeMethod("isClass", 0, this::isClassDef)
         defineNativeMethod("toString", 0, this::toStringDef)
     }
 
     private fun getSuperclassDef(interpreter: Interpreter, arguments: List<Any?>?) = (interpreter.thisInstance as LoxClass).superclass
 
+    private fun getTraitsDef(interpreter: Interpreter, arguments: List<Any?>?) : String{
+        val self = interpreter.thisInstance as LoxClass
+        var traits = ""
+        self.traits?.forEach { trait ->
+            traits += "${trait.name} " + trait.printParents()
+        }
+        return traits
+    }
+
     private fun isClassDef(interpreter: Interpreter, arguments: List<Any?>?) = true
 
     private fun toStringDef(interpreter: Interpreter, arguments: List<Any?>?) = interpreter.thisInstance.className

src/main/kotlin/common/LoxNativeClass.kt

@@ -4,14 +4,15 @@ import com.mysidia.ktlox.interpreter.Interpreter
 
 abstract class LoxNativeClass(name: String,
                               superclass: LoxClass?,
-                              metaclass: LoxClass? = null) : LoxClass(name, superclass, mutableMapOf(), metaclass){
+                              traits: MutableList<LoxTrait>? = null,
+                              metaclass: LoxClass? = null) : LoxClass(name, superclass, mutableMapOf(), traits, metaclass){
 
     fun defineNativeGetter(name: String, body: (interpreter : Interpreter, arguments: List<Any?>?) -> Any?){
         methods[name] = LoxNativeMethod(name, 0, true, null, body)
     }
 
     fun defineNativeMetaclass(name: String, superclass: LoxClass? = LoxClassClass){
-        klass = LoxClass(name, LoxClassClass, mutableMapOf(), null)
+        klass = LoxClass(name, superclass, mutableMapOf(), null, LoxClassClass)
     }
 
     fun defineNativeMethod(name: String, arity: Int, body: (interpreter : Interpreter, arguments: List<Any?>?) -> Any?){

src/main/kotlin/common/LoxNativeFunction.kt

@@ -4,10 +4,10 @@ import com.mysidia.ktlox.interpreter.Interpreter
 
 abstract class LoxNativeFunction(protected val name: String,
                                  override val arity: Int,
-                                 protected val body: () -> Any?
+                                 protected val body: (arguments: List<Any?>?) -> Any?
 ) : LoxObject(LoxFunctionClass), LoxCallable {
 
     override val isGetter = false
-    override fun call(interpreter: Interpreter, arguments: List<Any?>?) = body.invoke()
+    override fun call(interpreter: Interpreter, arguments: List<Any?>?) = body.invoke(arguments)
     override fun toString() = "<native fn: $name>"
 }

src/main/kotlin/common/LoxObjectClass.kt

@@ -8,15 +8,16 @@ object LoxObjectClass : LoxNativeClass("Object", null){
         defineNativeMetaclass("Object class")
         defineNativeGetter("className", this::classNameProp)
         defineNativeMethod("getClass", 0, this::getClassDef)
-        defineNativeMethod("getClassName", 0, this::getClassNameDef)
         defineNativeMethod("hashCode", 0, this::hashCodeDef)
+        defineNativeMethod("hasTrait", 1, this::hasTraitDef)
         defineNativeMethod("instanceOf", 1, this::instanceOfDef)
         defineNativeMethod("isBoolean", 0, this::isBooleanDef)
         defineNativeMethod("isClass", 0, this::isClassDef)
         defineNativeMethod("isNil", 0, this::isNilDef)
         defineNativeMethod("isNilOrEmpty", 0, this::isNilOrEmptyDef)
         defineNativeMethod("isNumber", 0, this::isNumberDef)
         defineNativeMethod("isString", 0, this::isStringDef)
+        defineNativeMethod("isTrait", 0, this::isTraitDef)
         defineNativeMethod("memberOf", 1, this::memberOfDef)
         defineNativeMethod("toString", 0, this::toStringDef)
     }
@@ -25,13 +26,20 @@ object LoxObjectClass : LoxNativeClass("Object", null){
 
     private fun getClassDef(interpreter: Interpreter, arguments: List<Any?>?) = interpreter.thisInstance.klass
 
-    private fun getClassNameDef(interpreter: Interpreter, arguments: List<Any?>?) = interpreter.thisInstance.className
-
     private fun hashCodeDef(interpreter: Interpreter, arguments: List<Any?>?) = interpreter.thisInstance.hashCode()
 
+    private fun hasTraitDef(interpreter: Interpreter, arguments: List<Any?>?) : Boolean{
+        val self = interpreter.thisInstance
+        val trait = arguments!![0] as? LoxTrait ?: return false
+        self.klass?.traits?.forEach {
+            if(it == trait || it.parents.contains(trait)) return true
+        }
+        return false
+    }
+
     private fun instanceOfDef(interpreter: Interpreter, arguments: List<Any?>?) : Boolean{
         val self = interpreter.thisInstance
-        val klass = arguments!![0] as? LoxClass ?: return false
+        val klass = arguments!![0] as? LoxClass ?: return hasTraitDef(interpreter, arguments)
         if(self.className == klass.name) return true
 
         var superKlass = self.klass
@@ -54,6 +62,8 @@ object LoxObjectClass : LoxNativeClass("Object", null){
 
     private fun isStringDef(interpreter: Interpreter, arguments: List<Any?>?) = false
 
+    private fun isTraitDef(interpreter: Interpreter, arguments: List<Any?>?) = false
+
     private fun memberOfDef(interpreter: Interpreter, arguments: List<Any?>?) : Boolean{
         val self = interpreter.thisInstance
         val klass = arguments!![0] as? LoxClass ?: return false

src/main/kotlin/common/LoxTrait.kt

@@ -2,7 +2,22 @@ package com.mysidia.ktlox.common
 
 class LoxTrait(val name: String,
                val methods: Map<String, LoxCallable>,
-               val parents: List<LoxTrait>? = null) : LoxObject(LoxTraitClass) {
+               val traits: List<LoxTrait>? = null) : LoxObject(LoxTraitClass) {
+
+    val parents : List<LoxTrait> by lazy {
+        val parentTraits = mutableListOf<LoxTrait>()
+        traits?.forEach {
+            parentTraits.add(it)
+            parentTraits.addAll(it.parents)
+        }
+        parentTraits
+    }
+
+    fun printParents() : String{
+        var parentTraits = ""
+        parents.forEach { parentTraits += "${it.name} " }
+        return parentTraits
+    }
 
     override fun toString() = name
 }

src/main/kotlin/common/LoxTraitClass.kt

@@ -6,15 +6,18 @@ object LoxTraitClass : LoxNativeClass("Trait", LoxObjectClass){
 
     init{
         defineNativeMetaclass("Trait class")
-        defineNativeMethod("parents", 0, this::parentsDef)
+        defineNativeMethod("getParentTraits", 0, this::getParentTraitsDef)
+        defineNativeMethod("isTrait", 0, this::isTraitDef)
     }
 
-    private fun parentsDef(interpreter: Interpreter, arguments: List<Any?>?) : String{
+    private fun getParentTraitsDef(interpreter: Interpreter, arguments: List<Any?>?) : String{
         val self = interpreter.thisInstance as LoxTrait
         var parents = ""
-        self.parents?.forEach {
-            parents += "${it.name} "
+        self.traits?.forEach { trait ->
+            parents += "${trait.name} " + trait.printParents()
         }
         return parents
     }
+
+    private fun isTraitDef(interpreter: Interpreter, arguments: List<Any?>?) = true
 }