附录 F. Java 互操作进阶
第 21 章讲了调用 Java 的日常用法:import、sprig api、判空、数值、lambda、集合、异常。这个附录把 JVM 边界上的细节一次说清楚,遇到具体问题时来查。里面的每条规则都来自编译器本身(sprig help jvm、sprig api),每条命令都真实运行过。
这一章你会学到:
sprig api除签名之外还告诉你什么;- 可空性注解怎么改变返回类型上的
?; - 泛型方法的类型实参:什么时候能推断,什么时候必须手写;
conform的两个方向:实现 Java 接口,以及用conform ... as parent继承 Java 类;- 函数式接口的边界,和为什么带
throws Error的函数值传不进去; - 受检异常在函数、顶层语句和
conform里的完整规则; --classpath和--classpath-file;- JVM 类型映射速查表。
F.1 sprig api:签名之外的元数据
为什么。 Java 重载多、注解多,肉眼猜不出来。sprig api 读的是编译器实际使用的元数据,和它一起测试。
--member 只看一个成员。对 final 类或接口,protectedMethods 是空的;对能被继承的类,它列出 protected 方法,以及谁会用到它们:
$ sprig api java.util.Random --member next
Java API: java.util.Random
constructors:
staticMethods:
instanceMethods:
fields:
protectedMethods (in a class declared with 'conform C to Random(...) as NAME': override them, call them as NAME.m(...)):
protected int java.util.Random.next(int) => next(Int32) -> Int32protected 方法不能直接在值上调用,只能在自己的类里用父类视图(F.5)。
加 --json 每个成员还带这些字段(后文用到哪个说哪个):
nullableResult:结果是否可能为null;interopLevel:互操作等级(direct、concrete-generic、opaque-array、adaptable、sprig-callable、java-callable、erased-generic、unsupported);interopReasonCodes:机器可读的原因,例如explicit-type-arguments-required、wildcard-bounds、generic-array-unsupported;usableFromSprig和unusableReason:这个成员能不能调用、不能的话为什么。
sprig api . 查整个项目;sprig api @std/lists.spr 查 Sprig 模块。api 只读签名,从不运行你的程序。
F.2 可空性注解
为什么。 默认规则(第 21 章)是「Java 引用结果一律可空,Java 形参一律非空」。库作者用注解表达得更精确时,Sprig 按注解来。
sprig help jvm 的规则原文:
- 结果默认可空,例外是
toString()和标注了NotNull/NonNull/Nonnull的结果,或类/包上有NullMarked、NonNullApi、MethodsReturnNonnullByDefault; - 形参标注
Nullable或CheckForNull时才能接受T?或null; - 只在 class 文件里保留的注解(CLASS 保留,例如
org.jetbrains.annotations)也读得到;注解按简单名匹配,每个库的拼法都算。
用一个自己的类验证。目录里放三个文件:
// src/fixture/NonNull.java
package fixture;
public @interface NonNull {}// src/fixture/Nullable.java
package fixture;
public @interface Nullable {}// src/fixture/Library.java
package fixture;
public class Library {
@NonNull
public String label() { return "ok"; }
@Nullable
public String nick() { return null; }
public String plain() { return "p"; }
}编译后用 --classpath(F.8 细讲)查签名:
$ javac -d out/classes src/fixture/*.java
$ sprig api fixture.Library --classpath out/classes --member label
Java API: fixture.Library
constructors:
staticMethods:
instanceMethods:
public java.lang.String fixture.Library.label() => label() -> String
fields:
$ sprig api fixture.Library --classpath out/classes --member nick
Java API: fixture.Library
constructors:
staticMethods:
instanceMethods:
public java.lang.String fixture.Library.nick() => nick() -> String?
fields:@NonNull 的 label 是 String(没有 ?),@Nullable 的 nick 是 String?,没标注的 plain 是 String?。所以 label() 可以不再判空:
import fixture.Library as Library
let lib = Library()
print(lib.label().toUpperCase())
let nick = lib.nick()
if nick == null:
print("no nick")$ sprig run use_library.spr --classpath out/classes
OK
no nick类一级的默认值(NullMarked 等)必须是运行时可见的注解(RUNTIME 保留)。给 Marked 类加上 RUNTIME 的 @NullMarked 后,没标注的结果也变成非空:
// src/fixture/NullMarked.java
package fixture;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface NullMarked {}$ sprig api fixture.Marked --classpath out/classes --member label
Java API: fixture.Marked
constructors:
staticMethods:
instanceMethods:
public java.lang.String fixture.Marked.label() => label() -> String
fields:@Nullable 的成员不受默认值影响,仍是 String?;而默认值永远不会把形参变成可空,只有显式标注 Nullable 的形参才接受 null——Sprig 从不主动把一个 null 交给 Java。
成员级的 @NonNull / @Nullable 还有一个细节:注解类即使不在 classpath 上,只要 class 文件里有它的名字就能识别。把 Library.class 单独拷进一个目录再查,结果不变。
学过其他语言?
Minecraft 的官方映射(Mojang mappings)用 JSpecify 在包上加 @NullMarked;Fabric Loader 用 org.jetbrains.annotations。所以调用模组 API 时,未标注的方法结果通常是非空的,标注 @Nullable 的才要判空。
F.3 泛型方法:推断还是手写
为什么。 Java 的静态方法常带自己的类型参数(<T> ...)。Sprig 的规则是:能从实参精确推断就推断,推不出来就必须写出 方法[类型](...)。
sprig help jvm 的原文:类型参数在「实参恰好固定每一个类型参数」时被推断;lambda、null、Sprig 集合、原始 Java 值都不提供信息,返回类型也不参与推断。实参本身能提供的就是精确的类型,比如形参 T 收 String 得 T = String,形参 List<T> 收 ArrayList[String] 得 T = String;同一个 T 出现两次必须得到同一个类型。
看一个能推断的例子,和一个必须手写的例子:
import java.util.ArrayList as ArrayList
import java.util.Collections as Collections
# sort 的约束是 T extends Comparable<...>,T 可以从实参推出来。
let names = ArrayList[String]()
names.add("grace")
names.add("ada")
Collections.sort(names)
print(names)
# 没有任何实参能定出 T 时,要自己写出类型实参。
let empty = Collections.emptyList[String]()
if empty != null:
print(empty.size())[ada, grace]
0逐行看:
Collections.sort(names)的签名带递归约束T extends Comparable<? super T>。names是ArrayList[String],T = String从实参推出来,约束在调用处检查通过(String实现Comparable[String]),排序原地进行。Collections.emptyList[String]()没有任何实参能定出T,所以把[String]写在方法名后面;结果仍然按 Java 引用规则是可空的List[String]?,所以先判空再size()。- 注意写法:
[String]紧跟在方法名后面,是类型实参,不是 Sprig 的集合下标。
推断有精确的边界:形参 List<T> 只接受具体的 Java 泛型实参(ArrayList[String] 可以),原始的 ArrayList() 不行;lambda 和 null 什么都不说明。写不出来的调用会像这样失败:
import java.util.stream.Collectors as Collectors
# toList 的返回类型拿不到任何实参信息;不写 [Int] 就调用不了。
let list = Collectors.toList()
print(list)SPR-JVM-MEMBER [JVM] main.spr:4:12: Java class Collectors has no method 'toList' matching 0 argument(s)
1 error(s); run 'sprig explain <code>' for details on a diagnostic code.报错说 toList 没有匹配 0 个实参的重载——它的类型参数没有实参可用。sprig check --json 在 data.candidates 里列出每个候选取不到的类型,repair.kind 是 inspect-api-and-make-arguments-explicit。修法就是 Collectors.toList[Int]()。
泛型实参之间是不变的:ArrayList[String] 可以当作 List[String](子类型投影到接口),但 ArrayList[Int32] 不能当 List[String],原始的 ArrayList() 也不会「变成」任何具体类型。
通配符保留边界。Sprig 自己没有通配符语法,但 Java 结果里可以出现,例如:
$ sprig api java.lang.Object --member getClass
Java API: java.lang.Object
constructors:
staticMethods:
instanceMethods:
public final native java.lang.Class<?> java.lang.Object.getClass() => getClass() -> java.lang.Class[?]?
fields:Class[?]? 这个值可以接收、判空、再传给别的 Java 方法,但不能在 Sprig 声明里写出来。带 ? extends 的容器只读:读取的元素按上界处理,任何写入(add)都会被拒绝。
import java.util.ArrayList as ArrayList
import java.util.List as List
import java.util.Collections as Collections
let numbers = ArrayList[Int]()
numbers.add(3)
numbers.add(1)
let frozen = List.copyOf[Int](numbers)
if frozen != null:
print(frozen)
let kind = numbers.getClass()
if kind != null:
print(kind.getSimpleName())
let view = Collections.unmodifiableList[Int](numbers)
if view != null:
print(view.get(0))[3, 1]
ArrayList
3F.4 用 conform 实现 Java 接口
为什么。 Java 框架要的是「实现了这个接口的对象」:线程要 Runnable,回调要 Consumer。Sprig 的类可以声明它满足一个 Java 接口,这个方法叫 conform:
import java.lang.Runnable as Runnable
import java.lang.Thread as Thread
class Greeter:
let name: String
func run() -> Unit:
print("hi " + name)
conform Greeter to Runnable
let task: Runnable = Greeter(name="ada")
task.run()
let thread = Thread(task)
thread.start()
thread.join()hi ada
hi ada逐行看:
class Greeter有一个func run() -> Unit,和Runnable唯一的抽象方法形状一致。conform Greeter to Runnable是一行声明,没有方法、没有适配;编译器验证形状后,生成的 Java 类把Runnable放进接口列表。let task: Runnable = Greeter(name="ada")把 Sprig 对象交给 Java 视角;Thread(task)照常接收。conform必须写在声明这个类的模块里:没有事后补救,也没有「形状对就算」的结构化匹配(第 16 章的契约类就要求显式conform)。
规则(sprig help conform):
- 目标必须是 import 进来的 public、非泛型、非 sealed 的 Java 接口;
- 每个抽象实例方法都要有一个同名、同参数 JVM 形状、同返回 JVM 形状的方法;重名的抽象方法(重载)不被支持;
- 一个类可以有多个接口
conform,但同一条关系只写一次; Task → Runnable和Task? → Runnable?成立,Task? → Runnable要先收窄;List[Task] → List[Runnable]永远不成立(泛型不变)。
F.5 扩展 Java 类:conform ... to J(fields) as parent
为什么。 有些 Java 框架要求你继承它的类并覆盖方法(比如模板方法)。Sprig 类没有继承,但可以用 conform C to J(字段, ...) as parent 让生成的类 extends J。
import java.util.Random as Random
# Counting 继承 java.util.Random:字段 seed 传给 Random(long) 构造器,
# 覆盖 protected 的 next(bits),用父类视图 parent 调用被覆盖的实现。
class Counting:
let seed: Int
var calls: Int = 0
func next(bits: Int32) -> Int32:
calls += 1
return parent.next(bits)
conform Counting to Random(seed) as parent
let rng = Counting(seed=42)
print(rng.nextInt(100))
print(rng.nextInt(100))
print(rng.calls)
let plain: Random = rng
print(plain.nextInt(100))
print(rng.calls)30
63
2
48
3逐行看:
class Counting有seed和calls两个字段,并定义next(bits: Int32) -> Int32。conform Counting to Random(seed) as parent:括号里的seed是Counting的字段,按顺序传给Random的那个 JVM 形状匹配的构造器(Random(long));as parent给父类实现起一个类内可见的名字。func next覆盖Random的 protectednext(int)(sprig api java.util.Random --member next能在protectedMethods里看到它)。方法体的parent.next(bits)就是 Java 的super.next(bits)。- 前两次
rng.nextInt(100)内部调用了被覆盖的next,所以rng.calls是 2。把rng交给父类视图后(let plain: Random = rng)再调一次得到48,随后打印的calls是 3:Random.nextInt内部调用的next仍然是Counting覆盖的那个,父类视图没有切开对象身份。
规则(sprig help conform 和 docs/jvm/conformance.md):
- 目标必须是 public、非 final、非泛型、非 sealed 的 Java 类(抽象或具体);
- 括号里只能是
C的字段名,不写表达式:super(...)在任何字段存在之前就运行了;conform C to J()选择无参构造器; - 名字和父类某个 public/protected 方法相同的
C方法,形状必须精确匹配其中之一,否则 Java 会悄悄生成一个重载、钩子永远不会被调用;覆盖final方法或遮挡static方法是SPR-CONFORM-MEMBER; parent不是值、没有字段、不能调抽象方法;protected 方法只能通过它调用,不能直接在有类型的值上调用;- 在
C的值上,未声明的方法照常通过 Java 视图解析(rng.nextInt(100)); - 泛型父类、第二个 Java 父类、构造器表达式都不在 v1 范围内。
F.6 函数式接口
为什么。 Java 用一个「只有一个抽象方法」的接口表示「待会儿要执行的代码」。Sprig 的 fn 值可以直接放在这些位置,参数类型必须写出。
import java.util.ArrayList as ArrayList
let names = ArrayList[String]()
names.add("ada")
names.add("bob")
names.add("cy")
# removeIf 收 Predicate,replaceAll 收 UnaryOperator:都是函数式接口。
names.removeIf(fn(name: String) => name.length() < 3)
print(names)
names.replaceAll(fn(name: String) => name.toUpperCase())
print(names)[ada, bob]
[ADA, BOB]removeIf收Predicate:fn(name: String) => name.length() < 3删掉短名字。replaceAll收UnaryOperator:它对每个元素原地替换,返回Unit也可以。- 两个接口的类型参数都通过接收者(
ArrayList[String])绑定了,所以 lambda 的参数类型写String就行。
规则:
- 一个抽象方法、没有方法级类型参数、最多三个参数;
- 形参类型必须和接口方法的映射完全一致(第 21 章的
SPR-SYNTAX-ERROR就是漏写类型); void的结果接受任何 lambda 结果;int结果也接受返回Int的 lambda(带运行时范围检查);- 接口类型实参里的通配符按上界读,例如实现
Consumer<String>的 lambda 满足Consumer<? super String>; - lambda 的类型必须不带
throws Error:Java 看不见这条信息。直接传进去会报:
import java.lang.Thread as Thread
# 这个函数值带 throws Error,Java 接口看不见这条信息。
func fail() -> Unit throws Error:
throw Error("no")
let thread = Thread(fn() => fail())
thread.start()
thread.join()SPR-TYPE-CALLABLE-THROWS [TYPE] main.spr:7:21: A function value that may throw Error cannot be passed to Java parameter 1 of Thread; Java cannot see the throws clause (expected fn() -> Unit, actual fn() -> Unit throws Error)
hint: Handle the error inside a named function and pass a lambda that calls it.
1 error(s); run 'sprig explain <code>' for details on a diagnostic code.修法是在 Sprig 这边把错误处理掉,再传一个不抛错误的函数值:Java 侧的接口只有 void run(),没有地方表达「可能失败」。
F.7 受检异常
为什么。 Java 把「可能失败」写进签名:IOException、SQLException 等受检异常必须处理。Sprig 把它们当成和 throws Error 同等的事实。
import java.nio.file.Files as Files
import java.nio.file.Paths as Paths
import java.io.IOException as IOException
# Files.readString 声明了 IOException,所以这个函数要么 catch,要么像这样声明。
func read_text(name: String) -> String throws IOException:
let path = Paths.get(name)
if path == null:
return ""
let text = Files.readString(path)
if text == null:
return ""
return text
try:
print(read_text("definitely-missing.txt"))
catch problem: IOException:
print("could not read: " + problem.toString())could not read: java.nio.file.NoSuchFileException: definitely-missing.txtFiles.readString带throws IOException,所以read_text的签名声明throws IOException,把责任传给调用者。- 顶层
try/catch problem: IOException:接住失败。NoSuchFileException是IOException的子类,一个catch能接住它。 - 异常对象是 Java 值:
problem.toString()一定有值,格式是类名: 消息;problem.message是String?,因为getMessage()可能返回null。 - Java 异常不是 Sprig 的
Error:catch problem: Error:接不住NoSuchFileException;反过来,Java 代码把 Sprig 错误转成文本时看到的是sprig.runtime.SprigError: 消息。 catch problem: IOException:里如果try块根本不会抛它,是SPR-FLOW-CATCH-NEVER-THROWN。
在命名函数里,受检异常要么 try/catch,要么写进 throws,二选一。顶层语句是临时例外:sprig check 不要求处理,程序运行时如果真抛出就中止:
$ sprig check toplevel.spr
$ sprig run toplevel.spr
SPR-RUNTIME-EXCEPTION [RUNTIME] toplevel.spr:6:5: NoSuchFileException: definitely-missing.txt
hint: Inspect the failing operation and the values it received. Run with --stacktrace to see the JVM stack.未受检异常(ArithmeticException、NumberFormatException)不要求声明,但也可以写进 throws;写不写都不影响调用者。
在 conform 里,见证方法的 throws 只能是 Java 接口方法允许的受检异常的子集,否则是 SPR-CONFORM-EFFECTS;Sprig 的 Error 映射为未受检的 SprigError,总是允许。
F.8 classpath:--classpath 和 --classpath-file
为什么。 用别人的 JAR 或自己 javac 出来的类时,要告诉编译器去哪里找。凡是有 --classpath 的命令(api、check、build、run、lsp)都同时有 --classpath-file。
$ javac -d out/classes src/fixture/*.java
$ sprig check use_library.spr --classpath out/classes
$ sprig check use_library.spr --classpath-file classpath.txt
$ echo $?
0classpath.txt 一行一个 JAR 或目录,空行和 # 注释会被忽略:
# one JAR or directory per line; blank lines and # comments are ignored
out/classes这个形式是给构建工具用的:Windows 的命令行有长度上限,一长串 --classpath 塞不下。重复的 --classpath 也可以,或用系统的路径分隔符一次给多个。
查找顺序是:JDK 运行时类 → 项目锁定的依赖 JAR(按记录顺序)→ 显式传入的条目;先找到的算。条目不存在时直接报错,不会悄悄忽略:
$ sprig api fixture.Library --classpath nope.jar
SPR-JVM-CLASSPATH [JVM] Classpath entry does not exist: .../nope.jar
1 error(s); run 'sprig explain <code>' for details on a diagnostic code.(真实输出是绝对路径。)在项目里不需要这些参数:sprig.toml 的 [[jvm]] 依赖由 sprig resolve 下载并锁定,api/check/build/run 自动使用锁定的 JAR(第 18 章)。
F.9 把 Java 类包装成 Sprig 源码:sprig wrap
为什么。 一个陌生的 Java 类,手抄方法签名容易出错。sprig wrap 读同样的 classpath,把能支持的方法生成成普通、可编辑的 Sprig 源码:
$ sprig wrap fixture.Library --classpath out/classes --out wrapped.spr
Wrapped fixture.Library -> .../wrapped.spr
generated: 4, skipped: 0生成的 wrapped.spr 开头几行:
# Generated by sprig wrap from fixture.Library.
# Ordinary Sprig source; safe to edit.
# Regeneration overwrites only with --force.
import fixture.Library as Host
class Library:
let host: Host
func label() -> String?:
return host.label()- 不支持的方法会被跳过并给出结构化原因(
varargs、通配符、泛型数组等),不会猜; --force才能覆盖已有文件;生成的源码先过检查再写盘;- 注意它很保守:
label有@NonNull,包装后还是String?,多判一次空总是安全的; --member可以只包装一个方法。
F.10 JVM 类型映射速查
| Java | Sprig | 说明 |
|---|---|---|
long | Int | 64 位整数 |
int、short、byte | Int32 | 32 位以内 |
double | Float | |
float | Float32 | Float 不会自动收窄 |
boolean | Bool | |
char | String | 一个 UTF-16 单元的字符串字面量 |
装箱类型(Long、Integer…) | 可空版本(Int?、Int32?…) | 结果默认可空 |
| 引用结果 | T? | toString() 和有非空注解的除外 |
byte[] 等数组 | 不透明值 | 用 HostBytes 助手处理 byte[] |
List/Map 等集合 | 不自动转换 | 用 @std/jvm 显式复制 |
几条容易忘的:
Int变量传给int/Integer形参时自动收窄并做运行时范围检查,有精确的long重载时仍优先long;字面量放不进int时在静态检查就报错(SPR-JVM-MEMBER)。Float永不自动变float:写toFloat32Lossy()(允许舍入)或toFloat32Exact()。- 数组不能构造、下标访问或遍历;
byte[]用HostBytes.utf8/utf8String/length/hex。 - 泛型类写具体实参(
ArrayList[String]()),泛型方法能推断就推断、不能就写(F.3)。 - Java 形参默认非空;
Int?传给int槽要先收窄(if x != null或or_else)。
本章小结
sprig api --json给nullableResult、interopLevel、interopReasonCodes等机器可读信息;protectedMethods配合父类视图使用。- 可空性注解按简单名匹配:
NotNull/NonNull/Nonnull让结果非空,Nullable/CheckForNull让形参接受null;类级默认值要求注解运行时可见,形参永远不因默认值变可空。 - 泛型方法在实参能精确固定类型参数时推断,否则写
method[Type](...);lambda、null、原始值不提供信息。 conform C to Interface声明实现;conform C to Class(fields) as parent让类继承 Java 类,并用父类视图调用被覆盖的super方法。fn值可以传给函数式接口,参数类型必须写;带throws Error的不行。- 受检异常在命名函数里必须处理或声明;顶层语句暂不强制;
conform里只能是接口允许的子集。 --classpath/--classpath-file使用和项目锁定依赖同一套查找顺序;sprig wrap把 Java 类生成成可编辑的 Sprig 源码。
动手练习
练习 1(简单)。 用 sprig api 查 java.lang.Integer.parseInt。哪个重载收 String?结果可空吗?
参考答案
$ sprig api java.lang.Integer --member parseInt
Java API: java.lang.Integer
constructors:
staticMethods:
public static int java.lang.Integer.parseInt(java.lang.CharSequence,int,int,int) throws java.lang.NumberFormatException => parseInt(CharSequence, Int32, Int32, Int32) -> Int32
public static int java.lang.Integer.parseInt(java.lang.String) throws java.lang.NumberFormatException => parseInt(String) -> Int32
public static int java.lang.Integer.parseInt(java.lang.String,int) throws java.lang.NumberFormatException => parseInt(String, Int32) -> Int32
instanceMethods:
fields:收 String 的重载是 parseInt(String) -> Int32。int 是基本类型,结果映射成不可空的 Int32(不是 Int32?)。
练习 2(简单)。 用 removeIf 和 lambda 从 ["ada", "alan", "bob"] 里删掉所有以 "a" 开头的名字,打印剩下什么。
参考答案
import java.util.ArrayList as ArrayList
let names = ArrayList[String]()
names.add("ada")
names.add("alan")
names.add("bob")
names.removeIf(fn(name: String) => name.startsWith("a"))
print(names)[bob]removeIf 收 Predicate,lambda 返回 Bool;startsWith 是 Java String 的方法。
练习 3(中等)。 把 F.5 的 Random 例子改成覆盖 nextInt(bound):统计 nextInt 被调用几次,并让每次调用都走父类实现。提示:方法签名是 nextInt(bound: Int32) -> Int32,和 Random 的 public 方法形状一致。
参考答案
import java.util.Random as Random
# 覆盖 public 的 nextInt(bound),数它被调用了多少次。
class Counting:
let seed: Int
var calls: Int = 0
func nextInt(bound: Int32) -> Int32:
calls += 1
return parent.nextInt(bound)
conform Counting to Random(seed) as parent
let rng = Counting(seed=42)
print(rng.nextInt(100))
print(rng.nextInt(100))
print(rng.calls)30
63
2nextInt 的形状和父类匹配,所以是覆盖;parent.nextInt(bound) 调用父类实现。两个 print(rng.nextInt(100)) 之后 calls 是 2。
练习 4(稍难)。 把 F.8 的 fixture 类目录写进 classpath.txt,用 --classpath-file 检查 use_library.spr,再故意把路径写错一次,看报什么。提示:文件里空行和 # 注释都可以有。
参考答案
$ cat classpath.txt
# one JAR or directory per line; blank lines and # comments are ignored
out/classes
$ sprig check use_library.spr --classpath-file classpath.txt
$ echo $?
0
$ sed -i '' 's|out/classes|out/typo|' classpath.txt
$ sprig check use_library.spr --classpath-file classpath.txt
SPR-JVM-CLASSPATH [JVM] Classpath entry does not exist: .../out/typo
1 error(s); run 'sprig explain <code>' for details on a diagnostic code.check 通过时没有输出、退出码 0。路径错了立刻报 SPR-JVM-CLASSPATH,并给出解析后的绝对路径。
回到:21. 调用 Java,或者用第 24 章的综合项目把学到的用起来。
学过其他语言?
如果你写过 Java:这里的 conform 一行同时是 implements 和 extends 的受限版本——接口方向零适配、显式声明,父类方向要求构造器字段和精确覆盖。sprig wrap 生成的代码就是普通 Sprig,可以当作调用陌生库的起点。
