Lib.rs

Binks 是一种解释型动态类型嵌入式脚本语言，试图尽可能简单，如 Python，尽可能简洁，100% 用 Rust 编写

项目信息：

功能

• 简单和清晰的语法
• 嵌入式
• 易于类型扩展
• 易于动态库加载

语法

Binks 的语法灵感来源于 Python、Rust 和 Dart。

变量通过 "let" 关键字声明，可以在整个程序中改变其类型。

函数通过 "fn" 关键字声明，后跟名称、括号内的参数以及以 { 开始以 } 结束的代码块。

if/elif/else 和 while 循环通过关键字 (if,elif...) 后跟布尔值（无需括号）以及以 { 开始以 } 结束的代码块来编写。

从动态库调用代码是通过使用 "extern" 关键字后跟函数路径、函数名称以及它所接受的参数，模式为：extern "path":"func":arg1,arg2,arg3

通过使用 "extend" 关键字扩展类型，后跟要扩展的类型，然后是在代码块中添加的所有函数，所有函数至少需要一个参数，可以以方法调用语法调用。

use "binks:IO.binks" as Io

fn fib(n) {
    if n == 1 || n == 2 {
        return n - 1	
    }
    return fib(n - 1) + fib(n - 2)
}

Io.println(fib(5))

extend str {
    fn str_method(self) {
        self = ": )"
    }

    fn str_method_2(self) {
        if self == ": )" {
            self = "0_o"
        }
    }
}

let s = ": ("
s.str_method()
s.str_method_2()
Io.println(s)

let x = 10

if 1 + 3 > 3.6 {
    Io.println("if statement!")
}

while x > 0 {
    x = x - 1
    if x == 5 {
        continue
    }
    Io.print(x)
    Io.print(" ")
}

Io.print("\n")

class XCounter {
    fn XCounter(self, x) {
        self.x = x
    }
    fn print_x(self) {
        Io.println(self.x)
    }
    fn increment(self) {
        self.x = self.x + 1
    }
    
}

let o = new XCounter("hello")
o.print_x()
o.x.str_method()
o.print_x()

let o2 = new XCounter(1)
o2.increment()
o2.print_x()

if o < o2 {
    Io.println("false")
}

if o != o2 {
    Io.println("true")
}

if o > o2 {
    Io.println("false")
}

安装

最新版本

要求：rust，git

$ git clone https://github.com/omrihhh/binks.git
$ cd binks
$ cargo build --release

然后添加 target\release 到你的路径

稳定版

要求：rust

cargo install binks

运行

$ binks <path> <stack size (2 by default)> 

在线尝试

Binks 操场

下一步

我希望实现的一些重要功能，使语言更加完整

• while 循环
• for 循环
• 类
• 更复杂的类和对象
• 运算符重载
• 默认/命名函数参数
• 导入
• 索引和更新的语法糖（array[1]，array[0] = 1）
• lambda函数
• libstd
• 嵌入式