[
{
"path": ".gitignore",
"content": "# macos #\n*/.DS_Store\n.DS_Store\n\n*.class\n\n# Mobile Tools for Java (J2ME)\n.mtj.tmp/\n\n# Package Files #\n*.jar\n*.war\n*.ear\n\n# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml\nhs_err_pid*\n\n# idea #\n*.iml\n\n# sh and bat #\n/latte\n/latte.bat\nbuild/*\n\n# gradle #\n.gradle/*\n"
},
{
"path": "LICENSE",
"content": "The MIT License (MIT)\n\nCopyright (c) 2016 KuiGang Wang\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README.md",
"content": "# Latte-Lang\n\n[](https://gitter.im/latte-lang/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)\n\n\n\nLatte is a JVM language. It's highly readable and extensible.\n\n[Syntax Mannual (NEW)](https://github.com/wkgcass/Latte-lang/blob/master/mannual-zh.md) \n[Latte WebSite](http://latte-lang.org/)\n\n`Atom` Extensions :\n\n[atom-latte-lang-highlighting](https://atom.io/packages/Atom-Latte-lang-Highlighting) \n[atom-latte-lang-ide](https://atom.io/packages/atom-latte-lang-ide)\n\n`Gradle` Plugin :\n\n[latte-gradle-plugin](#gradle-plugin)\n\n## 中文版戳[这里](#readme-ch)\n\n### Latte supports\n\n* Operator Binding\n* DSL\n* Data Class\n* Pattern Matching\n* Inner Method\n* Lambda and High-Order Function\n* JSON Literal\n* Regular Expression\n* Read Eval Print Loop\n* Compiling to JavaScript\n* Latte Gradle Plugin\n* JSR 223\n* many other features\n\n`Latte` is based on java 6. It's compiled to JVM byte code, and can collaborate with any java library.\n\n# How to build\n\n`JDK 1.6` or higher is the only thing required.\n\nThe project is managed by `Gradle`, you can use `Gradle 2.12` (or higher) to build automatically \nA build script is also provided.\n\nclone the repository, and run\n\n\t./build.py\n\nYou will get a shell scripts. The shell scripts can help you run the `repl`.\n\n>The build script does not support windows. Please follow the order (latte-[class-recorder | compiler | gradle-plugin | library | build]) to run `gradle clean latteBuild` in each directory, then extract `build/distributions/latte-${version}.zip` in module `latte-build`, the shell script is in the `bin` directory.\n\n\nrun:\n\n\t./latte\n\nthen the [REPL](https://github.com/wkgcass/Latte-lang/blob/master/latte-build/src/main/java/lt/repl/REPL.java) starts\n\n\tWelcome to Latte lang\n\tType in expressions and double Enter to have them evaluated.\n\tType :help for more information.\n\tfor syntax help, please visit https://github.com/wkgcass/Latte-lang/\n\n lt> 1+1\n |\n res0 : java.lang.Integer = 2\n\n lt>\n\n# Compile `lt` Files\n\nThere are two ways of compiling `lt` files\n\n* use program command\n\n\t\tlatte -c \n\n\tthe detailed commands and options can be found in\n\n\t\tlatte -help\n\nor:\n\n* start the `REPL` interpreter, and construct a `Compiler`\n\n\t\tcompiler = Compiler()\n\n\tuse `>>` operator to specify output directory\n\n\t\tcompiler >> '...'\n\t\t// or\n\t\tcompiler >> File('...')\n\n\tuse `+` operator to add class-path\n\n\t\tcompiler + '...'\n\n\tuse `compile MAP` to specify source codes to be compiled and start compiling\n\n\t\tcompiler compile ['fileName':FileObject]\n\n\tusually `filesInDirectory('...', regex)` is used, e.g.\n\n\t\tcompiler compile filesInDirectory('...', '.\\*\\\\.lt'.r)\n\n\tthese method invocations can be chained up\n\n\t\tCompiler() + '...cp...' >> '...output...' compile filesInDirectory('...source...', '.\\*\\\\.lt'.r)\n\n\tYou can write a `script` to configure the settings. Check [build.lts.template](https://github.com/wkgcass/Latte-lang/blob/master/latte-compiler/src/main/resources/build.lts.template) for more info.\n\n# Scripts\n\n* you can run a script directly\n\n\t\tlatte -s script-location script-arguments...\n\nor:\n\n* start the `REPL` interpreter \n\ttype `:script \ndata class script(typ) : HTMLElementWithClosing\n toString():String = toString(['type':typ])\n pretty(indentation:int=0):String = pretty(['type':typ], indentation)\n\n// \ndata class link(typ) : HTMLElement\n toString():String = toString(['type':typ])\n pretty(indentation:int=0):String = pretty(['type':typ], indentation)\n\n// ...\ndata class body : HTMLElementWithClosing\n toString():String = toString({})\n pretty(indentation:int=0):String = pretty({}, indentation)\n\n// ...\ndata class a : HTMLElementWithClosing\n toString():String = toString({})\n pretty(indentation:int=0):String = pretty({}, indentation)\n\n// \ndata class br : HTMLElement\n toString():String = toString({})\n pretty(indentation:int=0):String = pretty({}, indentation)\n\n// \ndata class button(typ) : HTMLElementWithClosing\n toString():String = toString(['type':typ])\n pretty(indentation:int=0):String = pretty(['type':typ], indentation)\n\n// ...\ndata class code : HTMLElementWithClosing\n toString():String = toString({})\n pretty(indentation:int=0):String = pretty({}, indentation)\n\n//
...
\ndata class div : HTMLElementWithClosing\n toString():String = toString({})\n pretty(indentation:int=0):String = pretty({}, indentation)\n\n//
\n\n单行注释使用`//`开头。例如\n\n```java\n// i am a comment\n```\n\n多行注释以`/*`开头，以`*/`结尾。例如\n\n```java\n/* comment */\n/*\nmultiple line comment\n*/\na/* comment */=1\n/* the comment splits an expression */\n```\n\n
\n\n```python\nif a > b\n return a\nelse\n return b\n```\n\n或者\n\n```kotlin\nresult = (if a > b {a} else {b})\n```\n\n>一个方法需要返回值，那么只要末尾一个值为表达式，Latte就会自动生成方法的return语句\n\n详见[2.3.1 If 语句](#p2-3-1)\n\n
1.1.9 for循环
\n\n```swift\nfor item in list\n println(item)\n```\n\n或者\n\n```swift\nfor i in 0 until list.size\n println(list[i])\n```\n\n详见[2.3.2 For 语句](#p2-3-2)\n\n
1.1.10 while循环
\n\n```swift\ni = 0\nwhile i < list.size\n println(list[i++])\n```\n\n详见[2.3.3 While 语句](#p2-3-3)\n\n
1.1.11 范围
\n\n检查x是否在范围中\n\n```kotlin\nif x in 1 to y-1\n print(\"OK\")\n```\n\n从1到5进行循环\n\n```swift\nfor x in 1 to 5\n print(x)\n```\n\n详见[5.2 范围](#p5-2)\n\n
\n\n```scala\nval (x,y) = Bean(1,2)\n```\n\n详见[5.9 解构](#p5-9)\n\n```scala\no match\n case Bean(a,b) => ...\n case People(name, age) if age > 20 => ...\n case _ => ...\n```\n\n详见[5.10 解构](#p5-10)\n\n
\n\n在转换时，所有基本类型都可以互相转换（除了bool，它可以被任何类型转换到，但不能转换为其他类型，详见[5.8 参数可用性检查](#p5-8)）而不会出现任何错误。但是，在高精度向低精度转换时可能会丢失信息。例如：\n\n```scala\ni:int = 3.14 /* i == 3 丢失了小数部分 */\n\nb:bool = 10 /* b == true 除了数字不是0外，信息都丢失了 (只有0在转换为bool时才会是false) */\n```\n\n
2.2.2 基本类型运算
\n\nLatte支持所有Java的运算符，并在其基础上有所扩展\n\n对于数字的基本运算，其结果均为“精度较高的值”的类型，且最低为`int`型。例如：\n\n```c#\nr1 = (1 as long) + (2 as int) /* r1 是 long */\nr2 = (1 as byte) + (2 as short) /* r2 是 int */\n```\n\n由于Latte可以任意转换基本类型，所以这么写也可以正常编译并运行：\n\n```java\na:short = 1\na+=1 /* a == 2 */\na++ /* a == 3 */\n```\n\n>由于Latte支持基本类型的互相转换，你可以直接把`int`的结果赋值给`short`。\n\nLatte支持所有Java运算符，当然也包括位运算。和`java`一样，位运算必须作用于整数上。Latte支持所有整数类型的位运算：`int/long/short/byte`。 \n此外，Latte还支持乘方运算：\n\n```groovy\na ^^ b\n```\n\n结果均为`double`型。\n\n> 本质来说，Latte不存在“运算符”。所有运算符都是方法调用。基本类型的运算是由其包装类型隐式转换后调用方法完成的。\n\n
2.3 控制流
\n\n
2.3.1 If 语句
\n\n和Java一样，if是一个语句而非像Kotlin，Scala那样作为表达式。\n\n但是，Latte支持`Procedure`，并且可以自动添加返回语句，所以使用起来和作为表达式区别并不大。\n\n```ruby\nif a > b\n return 1\nelse\n return 2\n\nval result = (if a>b {1} else {2})\n```\n\n
2.3.2 For 语句
\n\nfor语句格式如下：\n\n```kotlin\nfor item in iter\n ...\n```\n\n其中`iter`可以是数组、Iterable对象、Iterator对象、Enumerable对象、Map对象。\n\n当`iter`为前4种时，for语句将把其包含的对象依次赋值给`item`并执行循环体。当`iter`为Map对象时，`item`是一个Entry对象，它来自`Map#entrySet()`。\n\n你也可以使用`to`或者`until`，并在循环体内使用下标来访问元素:\n\n```kotlin\nfor i in 0 until arr.length\n val elem = arr[i]\n ...\n```\n\n
\n\n类通过`class`关键字进行定义\n\n当类内部不需要填充任何内容时，可以非常简单的书写为：\n\n```kotlin\nclass Empty\n```\n\n当需要提供构造函数参数时，写为：\n\n```kotlin\nclass User(id, name)\n```\n\n当然，你也可以为参数指定类型：\n\n```scala\nclass User(id:int, name:String)\n```\n\n如果不指定类型则类型视为`java.lang.Object` \n\nLatte不支持在类内部再定义构造函数，不过，你可以指定参数默认值来创建多个构造函数：\n\n```scala\nclass Rational(a:int, b:int=1)\n```\n\n此时你可以使用`Rational(1)`或者`Rational(1, 2)`来实例化这个类。\n\n--\n\n构造函数内容直接书写在class内：\n\n```kotlin\nclass Customer(name: String)\n logger = Logger.getLogger('')\n logger.info(\"Customer initialized with value ${name}\")\n```\n\n直接定义在类中的变量，以及构造函数参数，将直接视为字段(Field)。也就是说，上述例子中定义的name和logger都是字段。详见 [3.3 字段和方法](#p3-3) 。\n\n--\n\n使用`private`修饰符来确保类不会被实例化：\n\n```kotlin\nprivate class DontCreateMe\n```\n\n在Latte中，所有类都是`public`的，所以，在`class`前的任何“访问关键字”均为该类构造函数的访问关键字。\n\n
3.1.2 继承
\n\n和Java一样：Latte是单继承，并且所有的类都默认继承自`java.lang.Object`。你可以使用类型符号`:`来指定继承的类。继承的规则和Java完全一致。\n\n```kotlin\nclass Base(p:int)\nclass Derived(p:int) : Base(p)\n```\n\n父类的构造函数参数直接在父类类型后面的括号中指定。\n\n如果使用了父类的无参构造函数，那么可以省略括号：\n\n```kotlin\nclass Example : Object\n```\n\n如果想指定一个类不可被继承，那么需要在它前面加上`val`修饰符：\n\n```kotlin\nval class NoInher\n```\n\n
\n\n使用`static`定义静态成员。static可以“看作”一个修饰符，也可以“看作”一个结构块的起始。例如：\n\n```js\nclass TestStatic\n static\n public val STATIC_FIELD = 'i am a static field'\n static func()=1\n```\n\n
3.2 接口
\n\nLatte接口遵循Java的接口定义。使用`interface`关键字:\n\n```kotlin\ninterface MyInterface\n foo()=...\n```\n\n定义了`abstract`方法`foo()`。\n\n让一个类实现接口，也使用类型符号`:`。\n\n```kotlin\nclass Child : MyInterface\n foo()=456\n\nchild = Child\nchild.foo /* result is 456 */\nchild.bar /* result is 123 */\n```\n\n接口可以拥有字段，但是和Java规则一样，字段必须是`static public val`（默认也是）。\n\n```kotlin\ninterface MyInterface\n FLAG = 1\n```\n\n接口也可以拥有`static`方法（和Java一样）\n\n```js\ninterface TestStaticMethod\n static\n method()=111\n\nTestStaticMethod.method() /* result is 111 */\n```\n\n
3.3 字段和方法
\n\n
3.3.1 定义字段
\n\n你可以在类或接口中定义字段：\n\n```kotlin\nclass Address(name)\n public street\n public city\n public state\n public zip\n\ninterface MyInterface\n FLAG = 1\n```\n\n在类中定义的字段默认被`private`修饰，可选的访问修饰符还有`public`, `protected`, `internal`。\n\n字段可以为`static`，只要写在static块中即可（接口默认就是static的，不需要修改）。也可以为不可变的，使用`val`修饰即可。由于构造函数参数也是字段，所以这些修饰符可以直接写在构造函数参数中。例如：\n\n```kotlin\nclass User(protected val id, public val name)\n```\n\n使用字段很简单，直接使用`.`符号访问即可，和Java一致。\n\n```kotlin\nval user = User(1, 'latte')\nuser.name /* result is 'latte' */\n\nval address = Address('home')\naddress.city = 'hz'\n```\n\nLatte提供所谓的`property`支持：使用`getter`和`setter`来定义`property`。详情见 [3.3.3 Accessor](#p3-3-3)\n\n
\n\nLatte支持所有Java的修饰符，但是名称可能有改动：\n\n* var 表示可变变量（可省略，默认即为可变）\n* val 表示不可变变量，或者不可被重载的方法，或者不可被继承的类\n* abstract 抽象类/方法\n* native 本地方法\n* synchronized 同步方法\n* transient 不持久化的字段\n* volatile 原子性的字段\n* strictfp 方法内的符点计算完全遵循标准\n* data 类是一个data class：详见 [3.5 data class](#p3-5)\n\n>`val` 其实就是Java的 `final`\n\n
3.5 Data Class
\n\n编译器会为data class的每一个字段生成一个getter和setter。并生成无参构造函数，`toString()`, `hashCode()`, `equals(Object)`方法。此外，还会实现Serializable和Cloneable接口。\n\n```kotlin\ndata class User(val name: String, val age: int)\n\nuser = User('cass', 22)\nuser.toString() /* result is User(name='cass', age=22) */\n```\n\n你也可以定义自己的getter/setter/toString/hashCode/equals，编译器将跳过对应方法的生成。\n\n
3.6 实例化
\n\nLatte不需要`new`关键字就可以实例化一个类。对于无参数的实例化，甚至不需要附加括号：\n\n```kotlin\nclass Empty\nempty = Empty\n\nclass User(id, name)\nuser = User(1, 'latte')\n```\n\n当然，Latte也允许你加上`new`：\n\n```scala\nempty = new Empty\nuser = new User(1, \"latte\")\n```\n\n不过，Latte中的`new`的“优先级”非常低，java中的`new X().doSth()`的写法在Latte中必须写为`(new X).doSth`这样的写法。\n\n> Latte中建议不要写new\n\n此外，Latte提供另外一种特殊的实例化方式 \n调用无参构造函数，并依次赋值：\n\n```python\nclass open(file, mode)\n public encoding\n\nf = open('/User/a', \"r\", encoding='utf-8')\n```\n\n这是一个语法糖，相当于如下Latte代码：\n\n```kotlin\nf = open('/User/a', \"r\")\nf.encoding = 'utf-8'\n```\n\n即：首先使用不带`=`的参数进行类型的实例化，然后把剩余“参数”看作对accessor的赋值操作。\n\n这个语法糖不光适用于Latte定义的data class，还可以支持任意具有无参构造函数，并有可访问的field或者[accessor](#p3-3-3)的对象。例如标准Java Bean就可以使用这个语法。\n\n```java\nclass User {\n private int id;\n private String name;\n public int getId() {\n return id;\n }\n public void setId(int id) {\n this.id = id;\n }\n public String getName() {\n return name;\n }\n public void setName(String name) {\n this.name = name;\n }\n}\n```\n\n
3.7 Object Class
\n\n```scala\nobject DataProviderManager\n def registerDataProvider(provider: DataProvider)\n ...\n val allDataProviders: Collection = ...\n```\n\n本质上，`object class`定义了一个类，但是这个类不能拥有构造函数的参数，构造函数为private，并拥有一个`static public val`的字段来存放单例。\n\nobject class可以继承父类、实现接口，其规则与普通的class完全相同\n\n```scala\nobject DefaultListener : MouseAdapter()\n def mouseClicked(e: MouseEvent):Unit\n ...\n def mouseEntered(e: MouseEvent):Unit\n ...\n```\n\n你可以直接使用类名来获取这个单例对象：\n\n```\nval o = DataProviderManager\n```\n\n
\n\nLatte支持和Java完全一样的Lambda语法：\n\n```java\nstrList.stream().\nmap(s->Integer.parseInt(s)).\nfilter(n->n>10).\ncollect(Collectors.toList())\n```\n\n从外观上看不出任何差别？没错，语法上完全一致（特别是使用大括号区分层次的时候）。 \n使用缩进的情况下，多行lambda可以这么写:\n\n```coffee\nstrList.stream.map(\n s-> s = s.subString(1)\n Integer.parseInt(s)\n)\n```\n\n>注：可以不写return，因为Latte会帮你把需要的return补上。这个特性适用于任何“编译为JVM方法”的语法。\n\n如果lambda只有一个参数（例如上述代码），那么名称和`->`可以被省略。其中，名称会被标记为`it`。\n\n```js\nstrList.stream.map\n it = it.subString(1)\n Integer.parseInt(it)\n```\n\n这个特性可以让代码更简洁，同时也可以构造更灵活的内部DSL\n\n```python\nlatteIsWrittenInJava\n if it is great\n star the repo\n```\n\n>做一丁点处理后，这是可以正常编译的代码！（不需要hack编译器）\n\n可以写成一行\n\n```coffee\nlatteIsWrittenInJava { if it is great { star the repo }}\n```\n\n此外Lambda的变量捕捉机制和Java不同。Latte可以在Lambda中的任何地方修改被捕获的变量。\n\n```coffee\nvar count = 0\n(1 to 10).forEach { count+=it }\nprintln(count)\n```\n\n
5. 其他
\n\n
5.1 Json 集合
\n\nLatte支持Json格式的字面量。\n\nJson数组：\n\n```js\nvar list = [1, 2, 3, 4]\n```\n\n使用Json的数组语法，可以创建一个`java.util.LinkedList`实例，也可以创建一个数组。这取决于你将它赋值给什么类型的变量，或者使用`as`符号把它转换为什么类型。\n\nint数组：\n\n```c#\n[1, 2, 3, 4] as []int\n```\n\nObject数组:\n\n```c#\n[1, 2, 3, 4] as []Object\n```\n\n在Latte中，你可以将一个`java.util.List`类型的对象转换为其它种类的Object。该特性将尝试使用无参构造函数构造目标类型对象，然后对每一个List中的元素，调用add方法。\n\n```kotlin\nclass JsonArray\n list = []\n def add(o)=list.add(o)\nres = [1,2,3] as JsonArray\n/*\n same as:\n res = JsonArray()\n for item in [1,2,3]\n res.add(item)\n */\n```\n\n--\n\nJson对象：\n\n```swift\nvar map = [\n 'one': 1,\n 'two': 2,\n 'three', 3\n]\n```\n\n其中`,`是不必须的。“换行”和`,`都可以用来来分割list的元素，以及map的entry\n\n在Latte中，你还可以把一个\"所有键都是string\"的map转换为指定类型的对象。\n\n```kotlin\ndata class Bean(hello, foo)\nres = [\n \"hello\" : \"world\"\n \"foo\" : \"bar\n] as Bean\n\n/* res will be Bean(hello=world, foo=bar) */\n```\n\n该转换将首先用无参构造函数构造指定类型，然后对map中每一个键，进行Latte的赋值操作。 \n不光可以显式的转换，还可以作为方法参数隐式转换过去。\n\n
\n\n在调用方法时，自动转换并不会做，因为并不确定变量的类型，也不确定方法参数需要哪种类型。 \n如果编译期没有找到方法，则会在运行时再获取参数对象的类型并进行方法的寻找。如果一定要在编译期确定调用何种方法，可以手动转换类型。\n\n```kotlin\nclass Data\n i:int\n def setI(i:int) { this.i=i }\n\nfun call(x)\n var data:Data = Data\n data.setI(x as int)\n```\n\n上述例子中，x类型不确定，但是可以显式地转化为int。\n\n
5.4 运算符绑定
\n\nLatte支持运算符“绑定”。Latte的运算符绑定策略非常简单。每个运算符都看作方法调用。`a+b`看作`a.add(b)`，`a*b`看作`a.multiply(b)`，`!a`看作`a.not()`\n\n这些运算符绑定依照`BigInteger`和`BigDecimal`的命名，所以你可以直接使用运算符来计算大数。\n\n```kotlin\na = BigInteger(3)\nb = BigInteger(4)\nc = a + b\n```\n\n若需要绑定运算符，只需要写出签名相符的方法即可，例如定义一个`Rational`类来表示分数：\n\n```kotlin\nclass Rational(a, b)\n add(that: Rational)=Rational(this.a * that.b + that.a * this.b, this.a * that.b)\n toString():String=\"${a}/${b}\"\n\na = Rational(1, 4) /* 1/4 */\nb = Rational(3, 7) /* 3/7 */\nc = a + b /* 19/28 */\n```\n\n有一些运算符是“复合”的，即：它们可以由多个操作构成。例如`++a`，就可以由`(a = a + 1 , return a)`构成。这类运算符不提供绑定，如果有需要，请绑定它们的展开式用到的运算符。\n\n下表描述了所有提供绑定的运算符，以及一些展开式规则：\n\n| 运算符 | 方法签名 |\n|----------|-------------------------|\n| a:::b | a.concat(b) |\n| a * b | a.multiply(b) |\n| a / b | a.divide(b) |\n| a % b | a.remainder(b) |\n| a + b | a.add(b) |\n| a - b | a.subtract(b) |\n| a << b | a.shiftLeft(b) |\n| a >> b | a.shiftRight(b) |\n| a >>> b | a.unsignedShiftRight(b) |\n| a > b | a.gt(b) |\n| a < b | a.lt(b) |\n| a >= b | a.ge(b) |\n| a <= b | a.le(b) |\n| a == b | a.eq(b) |\n| a != b | !a.ne(b) |\n| a in b | b.contains(a) |\n| a & b | a.`and`(b) |\n| a ^ b | a.xor(b) |\n| a | b | a.`or`(b) |\n| !a | a.logicNot() |\n| ~a | a.not() |\n| -a | a.negate() |\n| a\\[0\\] | a.get(0) |\n| a\\[0, 1\\] | a.get(0, 1) |\n\n> `+a` 这种用法在Latte中不对`+`做任何处理，当做`a` \n> 上面的`a[0, 1]`用法，如果a是一个二维数组，则相当于java的`a[0][1]` \n> Latte对所有对象均可隐式转换到`RichObject`，在其中提供了`==`和`!=`的绑定，其中会调用对象的`equals`方法\n\nLatte的运算符优先级和Java完全一致，而Latte特有的运算符优先级如下：\n\n* `in` 和 `==` 优先级相同\n* `:::` 优先级最高\n\n由于`==`被绑定到equals方法，所以检查引用相同使用`===`，引用不同使用`!==`。 \n此外，Latte还提供两个运算符`is`和`not`，它除了可以检查引用、equals，在右侧对象是一个Class实例时还可以检查左侧对象是否为右侧对象的实例。\n\n> 虽然`==`绑定到equals方法，但是如果写为`null==x`，编译器能够知道左侧一定为null，这时会检查null值而不是调用equals\n> `!=`同理。\n\n| 运算符 | 展开式 |\n|--------|----------------------------------|\n| a?=b | a = a ? b |\n| a++ | tmp = a , a = a + 1 , return tmp |\n| ++a | a = a + 1 , return a |\n| a-- | tmp = a , a = a - 1 , return tmp |\n| --a | a = a - 1 , return a |\n\n> 其中`?=`的`?`代表任何二元运算符\n\n---\n\nLatte中，和普通的方法调用不同，运算符前不需要附加`.`，也不需要对参数包裹括号。但是因为Latte的运算符和方法调用是一回事，所以为了一致性，普通方法调用也可以将方法名看作运算符来书写：\n\n```scala\nlist isEmpty // list.isEmpty()\nmap put \"Feb\", 2 // map.put(\"Feb\", 2)\n.println o // println(o)\n```\n\n使用逗号分隔多个参数。使用`.`表示直接调用方法（而不是在某个对象或者某个类上调用）。\n\n
5.5 异常
\n\nLatte和Java总体上是类似的，但是仍有多处不同：\n\n* Latte没有`checked exception`\n* Latte可以`throw`任何类型的对象，比如`throw 'error-message'`\n* Latte可以`catch`任何类型的对象\n* 由于上一条，Latte不提供`catch(Type e)`这种写法，需使用if-elseif-else来处理\n\n```kotlin\nfun isGreaterThanZero(x)\n if x <= 0 { throw '${x} is littler than 0' }\n\nvar a = -1\ntry\n isGreaterThanZero(a)\ncatch e\n e.toCharArray /* succeed. `e` is a String */\nfinally\n a = 1\n```\n\n
![](\"http://latte-lang.org/static/Latte-lang-logo-large.png\"){kind=logo}
\n\nLatte is a JVM language. It's highly readable and extensible.\n\n[Syntax Mannual (NEW)](https://github.com/wkgcass/Latte-lang/blob/master/mannual-zh.md) \n[Latte WebSite](http://latte-lang.org/)\n\n`Atom` Extensions :\n\n[atom-latte-lang-highlighting](https://atom.io/packages/Atom-Latte-lang-Highlighting) \n[atom-latte-lang-ide](https://atom.io/packages/atom-latte-lang-ide)\n\n`Gradle` Plugin :\n\n[latte-gradle-plugin](#gradle-plugin)\n\n## 中文版戳[这里](#readme-ch)\n\n### Latte supports\n\n* Operator Binding\n* DSL\n* Data Class\n* Pattern Matching\n* Inner Method\n* Lambda and High-Order Function\n* JSON Literal\n* Regular Expression\n* Read Eval Print Loop\n* Compiling to JavaScript\n* Latte Gradle Plugin\n* JSR 223\n* many other features\n\n`Latte` is based on java 6. It's compiled to JVM byte code, and can collaborate with any java library.\n\n# How to build\n\n`JDK 1.6` or higher is the only thing required.\n\nThe project is managed by `Gradle`, you can use `Gradle 2.12` (or higher) to build automatically \nA build script is also provided.\n\nclone the repository, and run\n\n\t./build.py\n\nYou will get a shell scripts. The shell scripts can help you run the `repl`.\n\n>The build script does not support windows. Please follow the order (latte-[class-recorder | compiler | gradle-plugin | library | build]) to run `gradle clean latteBuild` in each directory, then extract `build/distributions/latte-${version}.zip` in module `latte-build`, the shell script is in the `bin` directory.\n\n\nrun:\n\n\t./latte\n\nthen the [REPL](https://github.com/wkgcass/Latte-lang/blob/master/latte-build/src/main/java/lt/repl/REPL.java) starts\n\n\tWelcome to Latte lang\n\tType in expressions and double Enter to have them evaluated.\n\tType :help for more information.\n\tfor syntax help, please visit https://github.com/wkgcass/Latte-lang/\n\n lt> 1+1\n |\n res0 : java.lang.Integer = 2\n\n lt>\n\n# Compile `lt` Files\n\nThere are two ways of compiling `lt` files\n\n* use program command\n\n\t\tlatte -c