语言速查
这页把 Sprig 的语法从头到尾过一遍,适合已经会一门编程语言、想快速上手的人。第一次接触 Sprig 的话,建议先做入门教程,再回来查这页。
页面上的每段代码都是仓库里 website/snippets/ 下的真实文件,文档检查时会实际编译运行。想确认某个特性有没有实现,以已实现功能清单(英文)为准。
缩进和注释
代码块靠缩进区分,和 Python 一样:
- 只能用空格缩进,用 Tab 会报
SPR-LEX-TAB。同一个块里的缩进要一致,空几格由你定。 - 文件里第一行代码要从第 1 列开始写。
- 在没有开始新块的地方缩进,或者
else:、if count > 0:这样的块头下面没有缩进的代码,报错会直接说明是哪种情况。 - 圆括号、方括号、花括号里面可以随意换行,所以长的调用和字面量可以拆成多行。
#后面是注释。
变量:let 和 var
# 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。
函数
# 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,见「错误处理」。
类
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的地方,通过契约的方法使用。契约没有字段、没有默认实现、不能构造,也不能反向转换。例子:
# 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
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 选一个值
# 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 表达式(英文)。
集合
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 新增):
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"))Coffee
Lunch
Taxi
food: 3050
transport: 3600
first ride: Taxi
true
2sort_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 设施。每个函数的说明见标准库说明(英文)。
可空值
# 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:
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)12
0
{tea: 2, rice: 1}
8080
port must be a number: eightyor_else返回这个值;值是null时返回你给的默认值。require返回这个值;值是null时抛出Error,消息由你来写。- 两个函数都不用在方括号里写类型:和其他泛型调用一样,类型从你传的值里来。(这比 v0.7.1-beta.1 新;在 v0.7.1-beta.1 里要写成
nulls.or_else[Int](...)。)
错误处理
# 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永远跑不到,编译器会报出来。
# 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)泛型
# 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
# 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。函数值不能用==比较。
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))函数类型
let inc: fn(Int) -> Int = fn(x: Int) => x + 1
print(inc(4))
let optional: (fn(Int) -> Int)? = nullfn(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里的函数都是这样写的。
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)[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 里查找字段
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:
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)Read the tour {"id":1,"title":"Read the tour","done":true}
$[1].id: expected integer, found stringrequired_int、required_string、required_bool返回字段的值;字段不存在、是null或类型不对时抛出Error。不做任何转换:字符串"2"不算整数。- 每条错误消息开头都写明出错的位置,这里是列表的第 1 个元素的
id字段。 optional_开头的版本在字段不存在或是null时返回null。root读取最外层是对象的文档,root_array读取最外层是列表的文档。object、member、int、text、bool用来构造要写回去的值。
模块
import "./math_module.spr" as math
print(math.square(7))
print(math.pi_approx)func square(x: Int) -> Int:
return x * x
let pi_approx: Float = 3.14159import "./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 互操作。
