Add lambda support(passing param as lambda

Author: ice1000

README.md

@@ -19,6 +19,9 @@ This is an interpreter for a dialect of lisp, running on JVM.
 
 ## [About the language](https://github.com/lice-lang/lice-reference)
 
+See [FeatureTest](src/test/kotlin/org/lice/FeatureTest.kt) to learn more about the language
+feature.
+
 ## It looks like:
 
 ```lisp
@@ -39,7 +42,7 @@ allprojects {
 }
 
 dependencies {
-  compile 'com.github.lice-lang:lice:v3.0.5'
+  compile 'com.github.lice-lang:lice:v3.1'
 }
 ```
 
@@ -48,15 +51,15 @@ But if you use Scala, you can add it to your sbt dependency, by adding the stuff
 ```sbtshell
 resolvers += "jitpack" at "https://jitpack.io"
 
-libraryDependencies += "com.github.lice-lang" % "lice" % "v3.0.5"
+libraryDependencies += "com.github.lice-lang" % "lice" % "v3.1"
 ```
 
 And if you're a Clojure developer, why not try build it with leiningen?
 
 ```leiningen
 :repositories [["jitpack" "https://jitpack.io"]]
 
-:dependencies [[com.github.lice-lang/lice "v3.0.5"]]
+:dependencies [[com.github.lice-lang/lice "v3.1"]]
 ```
 
 ## Contribute

build.gradle

@@ -1,8 +1,8 @@
 group 'org.lice'
-version '3.0.5'
+version '3.1'
 
 buildscript {
-	ext.kotlin_version = '1.1.1'
+	ext.kotlin_version = '1.1.2'
 	repositories {
 		mavenCentral()
 	}

src/main/kotlin/org/lice/compiler/model/Ast.kt

@@ -46,6 +46,8 @@ interface Node {
 	//	fun eval(params: List<Node> = emptyList<Node>()): Node
 	fun eval(): Value
 
+	fun process() = this
+
 	val meta: MetaData
 
 	override fun toString(): String
@@ -92,6 +94,7 @@ class ExpressionNode(
 
 	override fun eval(): Value {
 		super.beforeEval()
+		val node = process()
 		return when (node) {
 			is SymbolNode -> node.eval(params)
 			is ExpressionNode -> node.eval(params)
@@ -101,13 +104,19 @@ class ExpressionNode(
 
 	fun eval(outer: List<Node>): Value {
 		super.beforeEval()
+		val node = process()
 		return when (node) {
 			is SymbolNode -> node.eval(params, outer)
 			is ExpressionNode -> node.eval(params)
 			else -> node.eval()
 		}
 	}
 
+	override fun process() = when (node) {
+		is SymbolNode -> node.function().invoke(meta, params)
+		else -> node.process()
+	}
+
 	override fun toString() = "function: <$> with ${params.size} params"
 }
 
@@ -130,7 +139,6 @@ class SymbolNode(
 
 	fun function() = symbolList.getFunction(name) ?: undefinedVariable(name, meta)
 
-
 	override fun toString() = "symbol: <$name>"
 }
 
@@ -140,7 +148,6 @@ class EmptyNode(override val meta: MetaData) : Node {
 		return Nullptr
 	}
 
-	//	override fun eval(params: List<Node>) = Nullptr
 	override fun toString() = "null: <null>"
 }
 

src/main/kotlin/org/lice/compiler/util/Extension.kt

@@ -11,43 +11,11 @@ package org.lice.compiler.util
 
 import org.lice.lang.Echoer
 
-var DEBUGGING = true
-
-var VERBOSE = true
-
 fun <T> T.println(): T {
 	Echoer.echoln(this)
 	return this
 }
 
-fun <T> T.debugOutput(): T {
-	if (DEBUGGING) Echoer.echoln(this)
-	return this
-}
-
-inline fun <T> T.debugApply(block: T.() -> Unit): T {
-	if (DEBUGGING) this.block()
-	return this
-}
-
-inline fun debug(block: () -> Unit) {
-	if (DEBUGGING) block()
-}
-
-inline fun verbose(block: () -> Unit) {
-	if (VERBOSE) block()
-}
-
-fun <T> T.verboseOutput(): T {
-	if (VERBOSE) Echoer.echoln(this)
-	return this
-}
-
-inline fun <T> T.verboseApply(block: T.() -> Unit): T {
-	if (VERBOSE) this.block()
-	return this
-}
-
 inline fun forceRun(block: () -> Unit) {
 	try {
 		block()

src/main/kotlin/org/lice/repl/Repl.kt

@@ -2,8 +2,6 @@ package org.lice.repl
 
 import org.lice.compiler.parse.buildNode
 import org.lice.compiler.parse.mapAst
-import org.lice.compiler.util.DEBUGGING
-import org.lice.compiler.util.VERBOSE
 import org.lice.compiler.util.println
 import org.lice.core.SymbolList
 import org.lice.lang.Echoer
@@ -18,33 +16,29 @@ import org.lice.lang.Echoer
 class Repl
 @JvmOverloads
 constructor(val symbolList: SymbolList = SymbolList(true)) {
-	var stackTrace: Throwable? = null
 
 	init {
 		"""Lice language repl $VERSION_CODE
 			|see: https://github.com/lice-lang/lice
 
-			|剑未佩妥，出门已是江湖。千帆过尽，归来仍是少年。
-			|Stay young stay simple, and make yourself naive."""
+			|剑未佩妥，出门已是江湖。千帆过尽，归来仍是少年。"""
 				.trimMargin()
 				.println()
 		Echoer.echo(HINT)
-		DEBUGGING = false
-		VERBOSE = false
 	}
 
 	fun handle(str: String): Boolean {
 		try {
 			mapAst(buildNode(str), symbolList).eval()
 		} catch(e: Throwable) {
-			stackTrace = e
+//			stackTrace = e
 			Echoer.echolnErr(e.message ?: "")
 		}
 		print(HINT)
 		return true
 	}
 
 	companion object HintHolder {
-		val HINT = "Lice > "
+		val HINT = "|> "
 	}
 }

src/test/kotlin/org/lice/FeatureTest.kt

@@ -383,20 +383,16 @@ ice1k
 	}
 
 	/**
-	 * mention:
-	 * () means evaluation
-	 * so if you nest expressions, it will be evaluated without passing the params.
-	 *
 	 * I'll show you the procedure:
 	 *
 	 * (((if true + -)) 11 11)
 	 * ((+) 11 11)
-	 * (0 11 11)
+	 * (+ 11 11)
 	 * 0
 	 */
 	@Test(timeout = 1000)
 	fun test27() {
-		assertEquals(0, Lice.run("(((if true + -)) 11 11)"))
+		assertEquals(22, Lice.run("(((if true + -)) 11 11)"))
 		assertEquals(0, Lice.run("+"))
 		assertEquals(0, Lice.run("-"))
 		assertEquals(1, Lice.run("*"))
@@ -478,4 +474,19 @@ side-effect
 (fuck +)
 """))
 	}
+
+	/**
+	 * expr will keep the parameter everywhere
+	 * lazy will eval params when first invoked
+	 * lambda will eval params before invoked
+	 *
+	 * conclusion: if you want to pass 'function'
+	 * as parameter, please use 'expr'.
+	 */
+	@Test(timeout = 1000)
+	fun test32() {
+		assertEquals(3, Lice.run("((expr op (op 1 2)) +)"))
+		assertEquals(0, Lice.run("((lazy op (op 1 2)) +)"))
+		assertEquals(0, Lice.run("((lambda op (op 1 2)) +)"))
+	}
 }