Latte lang

100% Java compatibility and Functional Programming.

wkgcass

131

Java

Latte-Lang

Latte is a JVM language. It’s highly readable and extensible.

Syntax Mannual (NEW)
Latte WebSite

Atom Extensions :

atom-latte-lang-highlighting
atom-latte-lang-ide

Gradle Plugin :

latte-gradle-plugin

中文版戳这里

Latte supports

Operator Binding
DSL
Data Class
Pattern Matching
Inner Method
Lambda and High-Order Function
JSON Literal
Regular Expression
Read Eval Print Loop
Compiling to JavaScript
Latte Gradle Plugin
JSR 223
many other features

Latte is based on java 6. It’s compiled to JVM byte code, and can collaborate with any java library.

How to build

JDK 1.6 or higher is the only thing required.

The project is managed by Gradle, you can use Gradle 2.12 (or higher) to build automatically
A build script is also provided.

clone the repository, and run

./build.py

You will get a shell scripts. The shell scripts can help you run the repl.

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.

run:

./latte

then the REPL starts

Welcome to Latte lang
Type in expressions and double Enter to have them evaluated.
Type :help for more information.
for syntax help, please visit https://github.com/wkgcass/Latte-lang/

lt> 1+1
  |
res0 : java.lang.Integer = 2

lt>

Compile `lt` Files

There are two ways of compiling lt files

use program command
```
  latte -c <source-directory>
```
the detailed commands and options can be found in
```
  latte -help
```

or:

start the REPL interpreter, and construct a Compiler
```
  compiler = Compiler()
```
use >> operator to specify output directory
```
  compiler >> '...'
  // or
  compiler >> File('...')
```
use + operator to add class-path
```
  compiler + '...'
```
use compile MAP to specify source codes to be compiled and start compiling
```
  compiler compile ['fileName':FileObject]
```
usually filesInDirectory('...', regex) is used, e.g.
```
  compiler compile filesInDirectory('...', '.\*\\.lt'.r)
```
these method invocations can be chained up
```
  Compiler() + '...cp...' >> '...output...' compile filesInDirectory('...source...', '.\*\\.lt'.r)
```
You can write a script to configure the settings. Check build.lts.template for more info.

Scripts

you can run a script directly

  latte -s script-location script-arguments...

or:

start the REPL interpreter
type :script <script file> and Enter

then use script run or script run ['string array'] to run the script

JSR 223

Latte-lang supports JSR 223 specification. Use getEngineByName("Latte-lang") to retrieve the scripting engine.

ScriptEngine engine = new ScriptEngineManager().getEngineByName("Latte-lang");
Object result = engine.eval("a = 1 + 3");
System.out.println(engine.get("a"));

Since Latte-lang is a compiling language, and it’s directly compiled to JVM byte code, you could even use the scripting engine in Latte source codes.

engine = ScriptEngineManager().getEngineByName("Latte-lang")
result = engine eval "a = 1 + 3"
.println result
.println engine.a

Gradle Plugin

A plugin for Gradle is provided, which helps you compile latte source codes.

How to use

step1

add the plugin configuration:

buildscript {
    dependencies {
        classpath 'org.latte-lang:latte-gradle-plugin:$VERSION'
    }
}

apply plugin: 'latte'

sourceSets {
    main {
        java
        latte.srcDirs = ['src/main/latte']
        resources
    }
    test {
        java
        latte
        resources
    }
}

latteConfig {
    afterJava = true
    afterGroovy = false
    fastFail = false
}

all configurations are optional

The plugin adds compileLatte and compileTestLatte tasks, where compileLatte is before classes task, and compileTestLatte is before testClasses task

step2

create a folder named latte in the same parent directory. The directory tree should be:

src
├── main
│   ├── java
│   │   └── \*.java    ; java source
│   ├── latte
│   │   └── \*.lt      ; latte source
│   └── resources
│       │── \*.lts     ; latte scripts
│       └── other resources
└── test
    ├── java
    │   └── \*.java
    ├── latte
    │   └── \*.lt
    └── resources
        ├── \*.lts
        └── other resources

step3

run

gradle clean jar

Syntax

visit the Latte WebSite

or read the mannual

中文版 Chinese Version README

Latte是一种JVM编程语言。它非常可读，同时也非常可扩展。

语法规则
 Latte 主页

Atom上的扩展插件:

atom-latte-lang-highlighting
atom-latte-lang-ide

Gradle Plugin :

latte-gradle-plugin

Latte 支持如下功能

运算符绑定
DSL
Data Class
模式匹配
内部方法
Lambda 和高阶函数
JSON 字面量
正则表达式
Read Eval Print Loop
编译到JavaScript
Latte Gradle Plugin
JSR 223
许多其它特性

Latte基于java6。它被编译到JVM字节码，可以与任何Java类库完美互通。

如何构建工程

环境仅仅需要 JDK 1.6 或更高

本工程使用 Gradle 进行管理，所以您也可以使用 Gradle 2.12(或更高) 进行自动Build
此外还提供了一个Build脚本

clone这个仓库,然后执行

./build.py

你将会获取一个shell脚本, shell脚本可以快捷地开启repl.

构建脚本不支持windows，请按latte-[class-recorder | compiler | gradle-plugin | library | build]顺序依次进入目录执行gradle clean latteBuild，并解压latte-build模块的build/distributions/latte-${version}.zip，其中的bin目录为shell脚本。

执行:

./latte

接着, REPL 将开始运行

Welcome to Latte lang
Type in expressions and double Enter to have them evaluated.
Type :help for more information.
for syntax help, please visit https://github.com/wkgcass/Latte-lang/

lt> 1+1
  |
res0 : java.lang.Integer = 2

lt>

编译 `lt` 文件

使用程序命令
```
  latte -c <source-directory>
```
详细的命令与选项可以这样找到
```
  latte -help
```

或者:

开启REPL, 然后构造一个Compiler
```
  compiler = Compiler()
```
使用 >> 运算符来指定编译输出目录
```
  compiler >> '...'
  // or
  compiler >> File('...')
```
使用 + 运算符来添加 class-path
```
  compiler + '...'
```
使用 compile MAP 来确定源代码并立即开始编译
```
  compiler compile ['fileName':FileObject]
```
通常来说会使用 filesInDirectory('...', regex), e.g.
```
  compiler compile filesInDirectory('/Users/me/src', '.\*\\.lt'.r)
```
这些方法调用可以被串联起来
```
  Compiler() + '...cp...' >> '...output...' compile filesInDirectory('...source...', '.\*\\.lt'.r)
```
您可以编写一个脚本 script 来配置这些属性。查看 build.lts.template 以获取更多信息。

Scripts

你可以直接运行脚本

  latte -s script-file-path script-arguments...

或者：

开启 REPL 解释器
输入 :script <script file> 并回车

然后使用 script run 或者 script run ['string array'] 来运行这个脚本

JSR 223

Latte-lang支持JSR223规范。使用getEngineByName("Latte-lang")来获取ScriptEngine。

ScriptEngine engine = new ScriptEngineManager().getEngineByName("Latte-lang");
Object result = engine.eval("a = 1 + 3");
System.out.println(engine.get("a"));

由于Latte-lang是一种编译型语言，并且它直接编译到JVM字节码，所以你甚至可以在Latte源代码中使用脚本引擎。

engine = ScriptEngineManager().getEngineByName("Latte-lang")
result = engine eval "a = 1 + 3"
.println result
.println engine.a

Gradle 插件

提供了一个Gradle的插件，这个插件可以用来编译和运行latte源文件和脚本（script）。

如何使用

step1

添加如下gradle plugin配置：

buildscript {
    dependencies {
        classpath 'org.latte-lang:latte-gradle-plugin:$VERSION'
    }
}

apply plugin: 'latte'

sourceSets {
    main {
        java
        latte.srcDirs = ['src/main/latte']
        resources
    }
    test {
        java
        latte
        resources
    }
}

latteConfig {
    afterJava = true
    afterGroovy = false
    fastFail = false
}

所有的配置项都是可选的

插件添加了 compileLatte 和 compileTestLatte 任务。compileLatte 在 classes 任务之前, compileTestLatte 在 testClasses 任务之前

step2

在同一个上级目录中创建名称为latte的目录。目录结构树应当为：

src
├── main
│   ├── java
│   │   └── \*.java    ; java source
│   ├── latte
│   │   └── \*.lt      ; latte source
│   └── resources
│       │── \*.lts     ; latte scripts
│       └── other resources
└── test
    ├── java
    │   └── \*.java
    ├── latte
    │   └── \*.lt
    └── resources
        ├── \*.lts
        └── other resources

step3

运行

gradle clean jar

语法

您可以从这两个地方获取语法规则

语法规则

Latte 主页

Latte lang

Latte-Lang

中文版戳这里

Latte supports

How to build

Compile lt Files

Scripts

JSR 223

Gradle Plugin

How to use

step1

step2

step3

Syntax

中文版 Chinese Version README

Latte 支持如下功能

如何构建工程

编译 lt 文件

Scripts

JSR 223

Gradle 插件

如何使用

step1

step2

step3

语法

Compile `lt` Files

编译 `lt` 文件