Skip to content

语言速查 ​

这页把 Sprig 的语法从头到尾过一遍,适合已经会一门编程语言、想快速上手的人。第一次接触 Sprig 的话,建议先做入门教程,再回来查这页。

页面上的每段代码都是仓库里 website/snippets/ 下的真实文件,文档检查时会实际编译运行。想确认某个特性有没有实现,以已实现功能清单(英文)为准。

缩进和注释 ​

代码块靠缩进区分,和 Python 一样:

  • 只能用空格缩进,用 Tab 会报 SPR-LEX-TAB。同一个块里的缩进要一致,空几格由你定。
  • 文件里第一行代码要从第 1 列开始写。
  • 在没有开始新块的地方缩进,或者 else:、if count > 0: 这样的块头下面没有缩进的代码,报错会直接说明是哪种情况。
  • 圆括号、方括号、花括号里面可以随意换行,所以长的调用和字面量可以拆成多行。
  • # 后面是注释。

变量:let 和 var ​

spr
# let binds once; var may be reassigned.
let name = "Ada"
var visits = 0
visits += 1

# Local bindings infer their type from the initializer.
let greeting = "Hello, " + name
print(greeting)
print(visits)
  • let 绑定之后不能再改,var 可以。
  • 局部变量可以不写类型,Sprig 会从等号右边推断。类的字段则必须写类型。
  • 把数字或其他值放进文本,直接用 +:"visits " + visits,不需要先转换。只有可能为 null 的值要先检查,见可空值。
  • 条件必须是 Bool。0、空字符串都不会被当成 false,if count: 会报 SPR-TYPE-CONDITION。

函数 ​

spr
# Named functions declare parameter and return types, including -> Unit.
func add(a: Int, b: Int) -> Int:
    return a + b

func factorial(n: Int) -> Int:
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(add(2, 3))
print(factorial(5))
  • 参数和返回值都要写类型。没有返回值就写 -> Unit。
  • 调用函数时按位置传参。创建对象时则要写字段名,见下面的「类」。
  • 可能失败的函数要在签名里写 throws,见「错误处理」。

类 ​

spr
class Hero:
    let name: String
    var health: Int = 100

    func heal(amount: Int) -> Unit:
        health += amount

    func describe() -> String:
        return name + " (" + health + " hp)"

# Class construction uses named fields only.
let hero = Hero(name="Ada", health=80)
hero.heal(15)
print(hero.describe())

# A record of let fields fits on one line; it is the same kind of class.
class Position(x: Int, y: Int)
let start = Position(x=0, y=3)
print(start)
print(start.y)
  • 字段用 let(创建后不能改)或 var(可以改)声明,可以带默认值。
  • 只有 let 字段、没有方法的小类可以写成一行:class Position(x: Int, y: Int)。它和块写法是同一种类;要 var 字段、默认值或方法,就用块写法。
  • 方法没有函数体的类是契约(contract)。另一个类写 conform Console to Sink,就必须有契约里的每个方法、类型完全一致;之后 Console 的值可以放在任何要 Sink 的地方,通过契约的方法使用。契约没有字段、没有默认实现、不能构造,也不能反向转换。例子:
spr
# A contract: a class whose methods have no body. Classes conform to it.
class Sink:
    func write(line: String) -> Unit
    func flush() -> Int

class Console:
    var written: Int = 0

    func write(line: String) -> Unit:
        written += 1
        print("console: " + line)

    func flush() -> Int:
        return written
conform Console to Sink

class Memory:
    let lines: MutableList[String] = []

    func write(line: String) -> Unit:
        lines.append(line)

    func flush() -> Int:
        return lines.size()
conform Memory to Sink

# The caller sees only the contract; any conforming object will do.
func log_all(lines: List[String], sink: Sink) -> Int:
    for line in lines:
        sink.write(line)
    return sink.flush()

print(log_all(["a", "b"], Console()))
print(log_all(["c"], Memory()))
  • 什么时候用 variant,什么时候用契约,一句话:一组封闭的类型用 variant,一组开放的类型用契约。 封闭,是指你在一个地方列完所有情况、match 必须全部覆盖;开放,是指任何模块都可以再加一个符合契约的类。
  • 契约在 0.8 语言里有三条定下来的规则,不是「还没做」。每条违反都会报错并告诉你怎么写:
    • 契约不能是泛型的。 generic T: 块里的 class Repository 会报 SPR-CLASS-ABSTRACT,泛型类也不能 conform。按元素类型各写一个契约(IntRepository),或者用一个泛型类把那一个操作放进 fn 字段里。
    • 契约是类型,不是约束。 requires T: Sink 会报 SPR-GENERIC-CONSTRAINT:直接把 Sink 写成参数类型,func drain(sink: Sink) -> Unit。requires 只接受 Equatable 和 Comparable。契约也不能 conform 到另一个契约。
    • 契约没有默认方法。 有的方法带函数体、有的不带,会报 SPR-CLASS-ABSTRACT。共享的行为写成接收契约的模块函数:func log_all(sink: Sink, lines: List[String]) -> Unit。
  • 另外:契约值不能转回类(没有向下转型),也不能对类或契约的值做类型判断,match 只用于 enum 和 variant;conform 只能写在声明这个类的模块里(不能给导入的类补 conform),有同名方法但没写 conform 的类也不算符合契约。
  • 创建对象时必须写字段名:Hero(name="Ada", health=80)。少写、写错名字、重复写,都会编译报错。
  • 方法里直接写字段名就能访问当前对象的字段,不用加前缀。
  • 参数和局部变量不能和字段同名。
  • 两个对象用 == 比较,问的是「是不是同一个对象」。两个 Point(x=1, y=2) 字段完全一样,也不相等:改了其中一个,另一个不会跟着变。想比较内容,就比较你关心的字段(a.id == b.id),或者改用 variant。

enum、variant 和 match ​

spr
variant Expr:
    Literal(value: Int)
    Add(left: Expr, right: Expr)

enum Mode:
    Fast
    Careful

# match must cover every case; there is no default branch.
func eval(expr: Expr) -> Int:
    match expr:
        case Expr.Literal as node:
            return node.value
        case Expr.Add as node:
            return eval(node.left) + eval(node.right)

func label(mode: Mode) -> String:
    match mode:
        case Mode.Fast:
            return "fast"
        case Mode.Careful:
            return "careful"

let tree = Expr.Add(
    left=Expr.Literal(value=20),
    right=Expr.Literal(value=22)
)
print(eval(tree))
print(label(Mode.Careful))
  • enum 的每个值都不带数据,比如 Mode.Fast。
  • variant 的每种情况可以带自己的字段,字段不可变。比如 Expr.Add 带着 left 和 right。
  • case Expr.Add as node: 把匹配到的值绑定到 node,然后就能读它的字段。
  • variant 和 enum 的值按内容比较:Shape.Circle(radius=1.0) == Shape.Circle(radius=1.0) 是 true。字符串、数字、列表和 Map 也一样。
  • match 要把每种情况都写出来。没有 default,没有通配分支,也不会贯穿到下一个分支。漏写、重复、写了不可能出现的情况,都会编译报错。
  • match 可以当语句用,每个分支写多行;也可以当表达式用(比如 return match ...),这时每个分支只能写一个表达式。

穷尽检查在改代码时最有用:给 variant 加一种情况,所有没处理它的 match 都会报错,一个都漏不掉。仓库里的 tests/visitor/ast_visitor.spr 是一个用 Sprig 写的小型 AST 解释器,测试时会实际运行,靠的就是这一点。

用 if 选一个值 ​

spr
# An if expression chooses a value. Each branch is one expression on its
# own line, and the else branch is required.
let count = 3
let label = if count == 1:
    "1 item"
else:
    count + " items"
print(label)

func shipping(cents: Int) -> Int:
    return if cents >= 5000:
        0
    elif cents >= 2000:
        299
    else:
        499

print(shipping(6400))
print(shipping(1200))

# Narrowing is the if statement's: after name == null, the elif and the
# else both use name directly.
func greet(name: String?) -> String:
    return if name == null:
        "Hello, stranger"
    elif name.length() > 8:
        "Hello, " + name.substring(0, 8) + "..."
    else:
        "Hello, " + name

print(greet(null))
print(greet("Ada"))
print(greet("Bartholomew"))
  • 能写表达式 match 的地方,if 也能产生一个值:=、return、throw 后面,以及 lambda 的函数体。每个分支是单独一行、缩进的一个表达式,elif 和 else 跟 if 开头的那一行对齐。
  • else 分支必须写,漏了会报 "An if expression needs an else branch";在你补上之前,文件的其余部分照常检查,编辑器功能也不受影响。不需要产生值的时候,就写普通的 if 语句:写在语句开头的 if 总是 if 语句。
  • 所有分支是同一个类型:这个位置要求的类型,比如 let ratio: Float = if ...;没有要求的话,就是第一个不是 null 的分支的类型。有 null 分支,结果就是可空类型。
  • 没有 Python 的 a if c else b,也没有 C 的 c ? a : b,编译器会提示你改用 if 表达式。
  • 圆括号里的换行会被忽略,所以 if 表达式不能直接写进调用里,写在调用里的 lambda 体中也不行。先把它,或者装着它的 lambda,用 let 绑定,再把名字传进去;也可以直接传一个具名函数。细节见 if 表达式(英文)。

集合 ​

spr
let immutable: List[Int] = [3, 1, 2]
let mutable: MutableList[Int] = immutable.toMutableList()
mutable.append(4)
mutable.sort()

print(immutable.contains(2))
print(2 in immutable)
print(mutable)
print(mutable[0])
print(immutable)  # toMutableList returns a new outer collection

let ages: Map[String, Int] = {"ada": 36, "bob": 41}
print(ages.get("ada"))
print(ages["missing"])
print("bob" in ages)
  • List[T] 和 Map[K, V] 是只读的,要修改就用 MutableList[T] 和 MutableMap[K, V]。对只读集合做修改会报 SPR-COLLECTION-IMMUTABLE。
  • toMutableList()、toList()、toMutableMap()、toMap() 都会复制出一个新的集合(只复制外面这一层),原来的集合不受影响。
  • 用 let 声明列表时如果不写类型,得到的是 MutableList。它可以直接传给参数类型为 List 的函数:函数看到的是同一个列表的只读视角,所以之后通过可变名字 append 的元素它也看得到;需要快照就调用 toList()。反过来 List 不会自动变成 MutableList,要用 toMutableList()。
  • 按键从 Map 里取值,得到的是可空类型,键不存在时是 null。
  • 支持下标、in、get、set、append、sort,以及 map、filter、forEach 这几个接收 lambda 的方法。
  • Map 的键不能是浮点数,因为 NaN 和正负零在相等比较和哈希上对不上。

按某个字段排序、分组、汇总或查找,用标准库的 @std/lists(v0.6.0-beta.1 新增):

spr
import "@std/lists.spr" as lists

class Expense:
    let item: String
    let category: String
    let cents: Int

let expenses: List[Expense] = [
    Expense(item="Coffee", category="food", cents=1250),
    Expense(item="Taxi", category="transport", cents=3600),
    Expense(item="Lunch", category="food", cents=1800),
]

for expense in lists.sort_by(expenses, fn(e: Expense) => e.cents):
    print(expense.item)

for group in lists.group_by(expenses, fn(e: Expense) => e.category):
    let total = lists.sum_by(group.items, fn(e: Expense) => e.cents)
    print(group.key + ": " + total)

let ride = lists.find(expenses, fn(e: Expense) => e.category == "transport")
if ride != null:
    print("first ride: " + ride.item)
print(lists.any(expenses, fn(e: Expense) => e.cents > 3000))
print(lists.count(expenses, fn(e: Expense) => e.category == "food"))
text
Coffee
Lunch
Taxi
food: 3050
transport: 3600
first ride: Taxi
true
2
  • sort_by 是稳定排序,排序的键要能比较大小(见泛型里的 Comparable)。sorted 给本身就能比较大小的元素排序,比如 List[String]。
  • group_by 按键第一次出现的顺序分组,每组里保持原来的顺序;键用 == 比较。
  • sum_by 把每个元素算出的一个 Int 加起来,sum 把 List[Int] 加起来。
  • find 返回第一个通过检查的元素,一个都没有就返回 null。any、all、count 接收同样的检查函数。
  • fold 从左到右把元素累积成一个结果,上面几个函数做不了的再用它。
  • first、last、take、drop、reversed、distinct、index_of、enumerate、zip 负责列表上的小活;@std/sets 提供 Set[T](sets.of[String]([...])、has、add、union);@std/random、@std/regex、@std/dates 各自包了一个 JDK 设施。每个函数的说明见标准库说明(英文)。

可空值 ​

spr
# T? marks expected absence. A checked value narrows to non-null inside the branch.
func find(words: List[String], target: String) -> String?:
    for word in words:
        if word == target:
            return word
    return null

let found = find(["alpha", "beta"], "beta")
if found != null:
    print("found " + found)
else:
    print("not found")

let missing = find(["alpha"], "gamma")
print(missing == null)

# elif and else see the earlier conditions false: no second check is needed.
func describe(count: Int?, verbose: Bool) -> String:
    if count == null:
        return "none"
    elif verbose:
        return "count " + count
    else:
        return "quiet " + count

print(describe(3, true))
print(describe(null, true))
  • 可能没有值的类型写成 T?。null 只能赋给 T?。
  • 用之前先检查。在 if x != null: 的分支里,x 就当作有值。从 v0.6.0-beta.1 开始,if x != null and x.length() > 3: 这样写也可以。
  • elif 和 else 知道前面的条件都不成立:if x == null: 之后的 elif flag: 分支和 else 分支里,x 都当作有值,不用再检查一遍。再写一次 x != null 也不报错,只是多余。
  • 提前返回也行:写了 if x == null: return ... 之后,后面的代码都把 x 当作有值。前面几个分支都提前返回的 if/elif 链也一样。
  • 把可能为 null 的值用在需要非空的地方,会报 SPR-TYPE-NULLABLE。
  • var 局部变量和类的字段都不会收窄,不管中间有没有调用函数:先把它复制到一个 let(let current = name),再判断 current。
  • Java 方法返回的对象默认当作可能为 null;例外是 toString() 的结果,以及库用注解标明不会为空的结果,见 JVM 互操作。

如果只是想要一个默认值,或者没有值就报错,用 @std/nulls(v0.6.0-beta.1 新增)可以省掉 if:

spr
import "@std/nulls.spr" as nulls

# A fallback for a missing value, in one line.
let stock: Map[String, Int] = {"tea": 12}
print(nulls.or_else(stock["tea"], 0))
print(nulls.or_else(stock["milk"], 0))

# Counting: start from 0 when the key is not there yet.
let counts: MutableMap[String, Int] = {}
for word in ["tea", "rice", "tea"]:
    counts[word] = nulls.or_else(counts[word], 0) + 1
print(counts)

# No sensible fallback: stop with an error that says what was missing.
func port(text: String) -> Int throws Error:
    return nulls.require(text.toIntOrNull(), "port must be a number: " + text)

try:
    print(port("8080"))
    print(port("eighty"))
catch problem: Error:
    print(problem.message)
text
12
0
{tea: 2, rice: 1}
8080
port must be a number: eighty
  • or_else 返回这个值;值是 null 时返回你给的默认值。
  • require 返回这个值;值是 null 时抛出 Error,消息由你来写。
  • 两个函数都不用在方括号里写类型:和其他泛型调用一样,类型从你传的值里来。(这比 v0.7.1-beta.1 新;在 v0.7.1-beta.1 里要写成 nulls.or_else[Int](...)。)

错误处理 ​

spr
# Recoverable failures use typed errors: func ... throws T, throw, try/catch.
func checkout(quantity: Int) -> Int throws Error:
    if quantity <= 0:
        throw Error("quantity must be positive")
    return quantity * 3

try:
    print(checkout(4))
catch problem: Error:
    print("rejected: " + problem.message)

try:
    print(checkout(0))
catch problem: Error:
    print("rejected: " + problem.message)
  • 函数在签名里用 throws 写明会抛出哪种错误。
  • 调用它的地方二选一:用 try / catch 处理(可以再加 finally),或者在自己的签名里也写上 throws。两样都不做,会报 SPR-FLOW-THROWS。
  • Error 有一个 message 字段。print(problem)、"failed: " + problem 和 problem.toString() 显示的也都是这条消息。
  • Java 的受检异常也能这样捕获,catch 后面写导入的 Java 异常类就行。这类异常按 Java 的格式显示,类名在前;它的 message 是 String?,因为 Java 的 getMessage() 可能返回 null。
  • 自己的错误类型叫错误类:一个带 message: String 字段的类,再加一句 conform NotFound to Error(message)。它可以抛出、在签名里写 throws NotFound、按名字捕获来读它的字段,也可以用 catch problem: Error: 一次接住所有种类。写在 catch Error 之后的 catch NotFound 永远跑不到,编译器会报出来。
spr
# An error class: a class with a message field that conforms to Error.
class NotFound:
    let message: String
    let sku: String
conform NotFound to Error(message)

func stock(sku: String) -> Int throws NotFound:
    if sku == "A1":
        return 7
    throw NotFound(message="no item " + sku, sku=sku)

func describe(sku: String) -> String:
    try:
        return "stock " + stock(sku)
    catch problem: NotFound:
        return "missing sku " + problem.sku

print(describe("A1"))
print(describe("ZZ"))
try:
    print(stock("QQ"))
catch problem: Error:
    print("as Error: " + problem.message)

泛型 ​

spr
# Generics: one or more parameters per block. A call or constructor takes its
# type arguments from its arguments; Box[Int](value=41) would mean the same.
generic T:
    class Box:
        let value: T

generic T:
    func identity(value: T) -> T:
        return value

let box = Box(value=41)
print(identity(box.value) + 1)

你自己写的类、variant 和函数可以放进 generic T:(或 generic K, V:)块里。调用时类型参数由实参算出来,所以 Box(value=42) 就是 Box[Int](这比 v0.7.1-beta.1 新,那个版本要写 Box[Int](value=42))。实参说明不了的时候,比如传的是空列表,就自己写出来:lists.first[String]([])。泛型没有协变和逆变。要对类型参数用 ==,需要在函数开头写 requires T: Equatable;要比较大小,写 requires T: Comparable。详细规则见泛型。

Lambda ​

spr
# Lambdas are expressions: fn(params) => expression. Arities 0 through 3.
let doubled = [1, 2, 3].map(fn(x: Int) => x * 2)
print(doubled)

let evens = [1, 2, 3, 4].filter(fn(x: Int) => x % 2 == 0)
print(evens)

let collected: MutableList[Int] = []
[1, 2, 3].forEach(fn(x: Int) => collected.append(x * 10))
print(collected)
  • lambda 是一个表达式:fn(x: Int) => x * 2。
  • 参数 0 到 3 个,函数体只能是一个表达式。函数体里可以调用会抛出 Error 的函数,这时 lambda 的类型会带上这一点(见下面的「函数类型」)。
  • lambda 不能捕获 var 局部变量,否则报 SPR-TYPE-CAPTURE。先把值复制到一个 let 里再用。
  • 具名函数、模块函数和方法不加括号就是函数值:items.map(shout)、lists.sum、counter.bump。它的类型就是转发它的 lambda 的类型,会不会抛 Error 也一样。方法引用在创建时就把接收者算好,之后接收者变量再变也不影响。泛型函数要写出类型参数:identity[Int]。print 只在要 fn(T) -> Unit 的地方可以当值用,比如 items.forEach(print)。Java 方法和内置方法仍然要写 lambda。函数值不能用 == 比较。
spr
import "@std/lists.spr" as lists

func shout(text: String) -> String:
    return text.toUpperCase() + "!"

class Counter:
    var count: Int = 0

    func bump(by: Int) -> Int:
        count += by
        return count

let words = ["pear", "fig"]
print(words.map(shout))               # a named function as a value
let total: fn(List[Int]) -> Int = lists.sum
print(total([1, 2, 3]))               # a module function as a value
let counter = Counter()
let bump = counter.bump               # a method reference: the receiver is fixed now
print(bump(2))
print(bump(3))
print(counter.count)
words.forEach(print)                  # print where a fn(String) -> Unit is expected
let flip = lists.reversed[String]     # a generic function writes its type arguments
print(flip(words))

函数类型 ​

spr
let inc: fn(Int) -> Int = fn(x: Int) => x + 1
print(inc(4))
let optional: (fn(Int) -> Int)? = null
  • fn(Int) -> Int 是类型,fn(x: Int) => x + 1 是值。
  • 参数 0 到 3 个。参数和返回类型必须完全一致:没有函数子类型,也不会自动转换。
  • 整个函数可空时要加括号:(fn(Int) -> Int)?。而 fn(Int) -> Int? 表示返回值可空。可空的函数值和其他可空值一样,调用前先判空。
  • 函数类型可以用在变量、字段、参数和返回值上,也可以作为显式的泛型参数。
  • 函数类型末尾可以写 throws Error,而且只能是 Error:fn(String) -> Int throws Error。调用了会抛 Error 的函数的 lambda 就是这个类型;调用这样的值和调用任何会抛错的函数一样,要么自己声明 throws Error,要么 try/catch。没有这个子句的值可以用在要求这个子句的地方,反过来不行(SPR-TYPE-CALLABLE-THROWS)。Java 的受检异常不能穿过函数值,要在具名函数里处理掉。
  • 只负责把回调的错误往外传的函数,用 rethrows 代替 throws:func twice(step: fn(Int) -> Int throws Error, value: Int) -> Int rethrows:。调用它时抛出的正好就是你传进去的 lambda 会抛的东西,所以传一个不会失败的 lambda 就是普通调用。@std/lists 里的函数都是这样写的。
spr
import "@std/lists.spr" as lists

func to_number(text: String) -> Int throws Error:
    let value = text.toIntOrNull()
    if value != null:
        return value
    throw Error("not a number: " + text)

# The lambda calls a throwing function, so its type is
# fn(String) -> Int throws Error, and the call through map throws too.
func numbers(items: List[String]) -> List[Int] throws Error:
    return items.map(fn(item: String) => to_number(item))

# rethrows: twice throws exactly what step throws. With a lambda that cannot
# fail, the call needs no try and no throws.
generic T:
    func twice(step: fn(T) -> T throws Error, value: T) -> T rethrows:
        return step(step(value))

try:
    print(numbers(["1", "2"]))
    print(numbers(["1", "x"]))
catch problem: Error:
    print("caught: " + problem)
print(twice(fn(n: Int) => n * 3, 2))
let parse: fn(String) -> Int throws Error = fn(text: String) => to_number(text)
try:
    print(parse("21"))
    print(lists.sum_by(["1", "2", "three"], fn(text: String) => parse(text)))
catch problem: Error:
    print("caught: " + problem)
text
[1, 2]
caught: not a number: x
18
21
caught: not a number: three

函数值可以传给 Java 期望函数式接口的参数(最多三个参数,比如 Comparator、Consumer、Runnable),也可以传给 Sprig 自带的 sprig.runtime.Fn0 到 Fn3,见 JVM 互操作。不确定的时候,用 sprig api <类名> --json 查一下实际签名。

在 JSON 里查找字段 ​

spr
import "@std/json.spr" as json

let document = json.parse("{\"name\":null}")
match json.find_member(document, "name"):
    case json.Lookup.Missing:
        print("missing")
    case json.Lookup.Found as member:
        print(json.stringify(member.value))  # prints null
    case json.Lookup.NotObject:
        print("expected an object")

json.find_member 的结果有三种:Missing(没有这个键)、Found(有,值在 value 里)和 NotObject(查的不是对象)。键存在但值是 null、false、0 或空字符串时,结果都是 Found,不会和「没有这个键」混在一起。对象里有重复的键会抛出 Error;成员保持原来的顺序。解析、查找和序列化的完整规则见标准库说明(英文)。

要读整条记录,用 @std/json_codec(v0.6.0-beta.1 新增)按名字和类型取字段,不用给每个字段写一遍 match:

spr
import "@std/json.spr" as json
import "@std/json_codec.spr" as codec

class Task:
    let id: Int
    let title: String
    let done: Bool

func decode_task(row: codec.Reader) -> Task throws Error:
    return Task(
        id=codec.required_int(row, "id"),
        title=codec.required_string(row, "title"),
        done=codec.required_bool(row, "done")
    )

func encode_task(task: Task) -> json.Value:
    return codec.object([
        codec.member("id", codec.int(task.id)),
        codec.member("title", codec.text(task.title)),
        codec.member("done", codec.bool(task.done))
    ])

let text = "[{\"id\": 1, \"title\": \"Read the tour\", \"done\": true}, {\"id\": \"2\", \"title\": \"Write code\", \"done\": false}]"
for row in codec.root_array(json.parse(text)):
    try:
        let task = decode_task(row)
        print(task.title + " " + json.stringify(encode_task(task)))
    catch problem: Error:
        print(problem.message)
text
Read the tour {"id":1,"title":"Read the tour","done":true}
$[1].id: expected integer, found string
  • required_int、required_string、required_bool 返回字段的值;字段不存在、是 null 或类型不对时抛出 Error。不做任何转换:字符串 "2" 不算整数。
  • 每条错误消息开头都写明出错的位置,这里是列表的第 1 个元素的 id 字段。
  • optional_ 开头的版本在字段不存在或是 null 时返回 null。
  • root 读取最外层是对象的文档,root_array 读取最外层是列表的文档。
  • object、member、int、text、bool 用来构造要写回去的值。

模块 ​

spr
import "./math_module.spr" as math

print(math.square(7))
print(math.pi_approx)
spr
func square(x: Int) -> Int:
    return x * x

let pi_approx: Float = 3.14159
  • import "./file.spr" as alias 导入另一个 Sprig 文件。
  • import 要写在文件开头,在所有声明和语句之前。
  • 每个模块只初始化一次。两个模块互相导入(导入环)会报 SPR-NAME-IMPORT-CYCLE。
  • 导入 Java 类也是这个写法,只是换成完整类名:import java.time.LocalDate as LocalDate。
  • 标准库以 @std 开头,比如 import "@std/json.spr" as json。

命名 ​

命名跟着 Sprig 代码里已经在用的写法走:

  • 你自己声明的名字用小写加下划线:函数、方法、参数、变量、字段、模块里的 let,还有导入时起的别名,比如 read_utf8、max_by、user_id。缩写也小写:write_utf8、escape_html。
  • 类型用大驼峰:类、契约类、variant、enum,以及它们的分支和类型参数,比如 HttpServer、Expr.Literal、Color.Red、T。
  • 没有全大写的常量。
  • 内置类型自带的方法(toString、toFloatExact、divTrunc、toIntOrNull)和 Java 的 API(ArrayList.add、Thread.MIN_PRIORITY)保留驼峰原名。实现或覆盖 Java 方法时,方法名跟 Java 一致。
  • 文件和目录也用小写加下划线:json_codec.spr、main.spr。包名(sprig.toml 里的 name、注册表里的名字)用小写加连字符:sprig-web。

sprig-cli 的 OptionKind.FLAG 和 sprig-web 的 Method.GET、SchemaType.STRING 这几个全大写的分支名是早先定的,保持不变。

另外几个小功能 ​

  • 字符串必须在同一行闭合;漏掉结尾引号或把字符串换到下一行时,SPR-LEX-STRING 会标出这行未闭合的字符串。
  • 在函数里用循环 text += part 拼出一大段文本,花的时间和文本长度成正比:这样的局部 var 在生成的代码里放在 builder 中,不会每一轮都把已有的内容复制一遍。模块顶层的 var 和字段不是这样,这类文本请放到函数里拼,或者把片段收进列表再用 text.join。见在循环里拼字符串(英文)。
  • sprig fmt 把代码整理成统一的格式,会保留注释,没有配置项。见格式化(英文)。
  • 模块可以用 export alias.Symbol 把导入的声明再导出,但不能借此绕过依赖包的导出范围。没有 export * 这样的通配导出。见重导出(英文)。
  • 表达式形式的 match 每个分支只能写一个表达式;要写多行,就用语句形式。见 match 表达式(英文)。

还没有的 ​

下面这些目前都还没有:

  • 从期望的类型推断类型参数,以及协变和逆变
  • 继承(开放多态用契约类,见类)
  • %=
  • 元组和解构
  • 字符串插值:"${name}" 只是普通文本。拼接用 +:两边放什么值都可以,"count " + count 不用写 toString(),显示效果和 print 一样。null、可能为 null 的值(比如 Int?)和返回 Unit 的调用不能拼。运算从左到右,所以 1 + 2 + " items" 是 3 items。

和 Java 打交道时,Sprig 没有数组语法,也没有自己的通配符语法。Java 数组可以原样接收和传递,变长参数方法直接把参数依次写在后面就行,Java 通配符会保留它的边界,见 JVM 互操作。

完整列表见已知限制(英文),后面的计划见路线图(英文)。

Sprig 采用 Apache-2.0 许可证 · v0.7.1-beta.1 已作为 prerelease 发布