Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
69 changes: 43 additions & 26 deletions bootstrap/s2c-seed.c

Large diffs are not rendered by default.

24 changes: 19 additions & 5 deletions s2/eff.srs
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,8 @@
// row(F, P) :- needs(F, P), not decl(F, P)
// req(F, P) is written only when no handle of P is in scope; scope 0 handles nothing. each row(F, P) is one implicit
// {eff.P: P} binder of F (Ty.fn); main has none, so a request main does not handle is error[unhandled-effect].
// a handler H is one subject F (E1b): its fns' bodies are its facts, and `handle x = H()` is calls(F, H, S) in the scope
// outside the handle, so the handlers outside it answer what its ops request (deep handlers, kyo semantics).

enum Eff.Rel:
case Eff.RReq
Expand Down Expand Up @@ -153,7 +155,7 @@ def Eff.cxOf {r: Region} (ds: Coll.List[Ast.Decl], cx: Eff.Cx): Eff.Cx = ds matc
case Ast.DProto(p) => Eff.cxOf(rest, Eff.Cx(Coll.Cons(p, ps), hp, fns, ctors, ss))
case Ast.DHandler(h) =>
val Ast.Handler(_, n, p, _) = h
Eff.cxOf(rest, Eff.Cx(ps, Coll.sInsert(hp, n, p), fns, ctors, ss))
Eff.cxOf(rest, Eff.Cx(ps, Coll.sInsert(hp, n, p), Coll.sInsert(fns, n, Eff.Runs), ctors, ss))
case Ast.DFn(f) =>
val Ast.Fn(_, n, _, _, _, _, _) = f
Eff.cxOf(rest, Eff.Cx(ps, hp, Coll.sInsert(fns, n, Eff.calleeOf(f)), ctors, ss))
Expand Down Expand Up @@ -205,18 +207,29 @@ def Eff.decls {r: Region} (cx: Eff.Cx, ds: Coll.List[Ast.Decl], w: Eff.W): Coll.
case Coll.Cons(d, rest) => d match
case Ast.DFn(f) =>
val Eff.W(n, fs, _, _) = w
Eff.decls(cx, rest, Eff.fn(cx, f, Eff.W(n, fs, Coll.Nil, Coll.sEmpty())))
val Ast.Fn(_, fname, _, _, _, _, _) = f
Eff.decls(cx, rest, Eff.fn(cx, fname, f, Eff.W(n, fs, Coll.Nil, Coll.sEmpty())))
// a handler is one subject: its row is what all its fns need (E1b), kept at its handle site
case Ast.DHandler(h) =>
val Eff.W(n, fs, _, _) = w
val Ast.Handler(_, hn, _, hfs) = h
Eff.decls(cx, rest, Eff.hfns(cx, hn, hfs, Eff.W(n, fs, Coll.Nil, Coll.sEmpty())))
case _ => Eff.decls(cx, rest, w)

// decl(F, P) for each {} binder of a protocol; the body of a run def (a spec def is pure: it has no row)
def Eff.fn {r: Region} (cx: Eff.Cx, f: Ast.Fn, w: Eff.W): Eff.W =
val Ast.Fn(_, n, gs, ps, _, _, body) = f
// n: the subject, the def itself or its handler
def Eff.fn {r: Region} (cx: Eff.Cx, n: Sym.Sym, f: Ast.Fn, w: Eff.W): Eff.W =
val Ast.Fn(_, _, gs, ps, _, _, body) = f
val ev = Ty.evidence(gs, Coll.Nil)
val w1 = Eff.declsOf(cx, n, ev, w)
body match
case Ast.Def(_, e) => Eff.expr(cx, Eff.At(n, 0, Coll.Nil, Ty.names(ps, Ty.names(ev, Coll.Nil))), e, w1)
case _ => w1

def Eff.hfns {r: Region} (cx: Eff.Cx, h: Sym.Sym, fs: Coll.List[Ast.Fn], w: Eff.W): Eff.W = fs match
case Coll.Nil => w
case Coll.Cons(f, rest) => Eff.hfns(cx, h, rest, Eff.fn(cx, h, f, w))

def Eff.declsOf {r: Region} (cx: Eff.Cx, f: Sym.Sym, bs: Coll.List[Ast.Binder], w: Eff.W): Eff.W = bs match
case Coll.Nil => w
case Coll.Cons(b, rest) =>
Expand Down Expand Up @@ -312,8 +325,9 @@ def Eff.stmts {r: Region} (cx: Eff.Cx, at: Eff.At, ss: Coll.List[Ast.Stmt], last
case Coll.Cons(s, rest) => s match
case Ast.Val(_, x, _, e) => Eff.stmts(cx, Eff.local(at, Coll.Cons(x, Coll.Nil)), rest, last, Eff.expr(cx, at, e, w))
case Ast.Var(_, x, _, e) => Eff.stmts(cx, Eff.local(at, Coll.Cons(x, Coll.Nil)), rest, last, Eff.expr(cx, at, e, w))
// the handler's row is needed here, in the scope outside its own handle (deep handlers, E1b)
case Ast.Handle(_, x, h, xs) =>
val Eff.W(n, fs, rq, cs) = Eff.exprs(cx, at, xs, w)
val Eff.W(n, fs, rq, cs) = Eff.call(cx, at, h, Eff.exprs(cx, at, xs, w))
val Eff.Cx(_, hp, _, _, ss) = cx
val Eff.Syms(_, _, _, hdRel, _) = ss
val Eff.At(f, _, hd, ls) = at
Expand Down
3 changes: 2 additions & 1 deletion s2/elab.srs
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,8 @@ enum El.Arm:
enum El.Stmt:
// a val or var with its type (emit declares the C local with it)
case El.Val(line: I64, x: Sym.Sym, ty: K.Term, mut: Bool, e: El.Expr)
case El.Handle(line: I64, x: Sym.Sym, h: Sym.Sym, args: Coll.List[El.Expr])
// caps: the handler's row (s2/eff.srs), the capabilities of the handle site it keeps for its ops (E1b)
case El.Handle(line: I64, x: Sym.Sym, h: Sym.Sym, caps: Coll.List[Sym.Sym], args: Coll.List[El.Expr])
case El.Do(e: El.Expr)

// a def: its [] binders (instantiated by mono), its protocol {} binders (leading C params), params with types
Expand Down
113 changes: 100 additions & 13 deletions s2/emit.srs
Original file line number Diff line number Diff line change
Expand Up @@ -364,6 +364,29 @@ def Emit.capArgs(env: Emit.Env, caps: Coll.List[Sym.Sym], s: Emit.Sep): Unit = c
Emit.local(Emit.vs(env), c)
Emit.capArgs(env, rest, Emit.Comma)

// h_H_init(caps, args): the handler's state
def Emit.initCall {r: Region} (cx: Emit.Cx, fi: Emit.Fi, env: Emit.Env, h: Sym.Sym, caps: Coll.List[Sym.Sym], args: Coll.List[El.Expr]): Unit =
Console.print("h_")
Emit.id(h)
Console.print("_init(")
Emit.capArgs(env, caps, Emit.First)
Emit.args(cx, fi, env, args, if Coll.length(caps) == 0 then Emit.First else Emit.Comma)
Console.print(")")

// a handler with a row (E1b): its state and the capabilities of the handle site, the self of its ops (srs_env)
def Emit.handleEnv {r: Region} (cx: Emit.Cx, fi: Emit.Fi, env: Emit.Env, v: Emit.Name, h: Sym.Sym, caps: Coll.List[Sym.Sym], args: Coll.List[El.Expr]): Unit = caps match
case Coll.Nil => ()
case Coll.Cons(_, _) =>
Console.print("struct { void* st; srs_cap* c[")
Console.printI64(Coll.length(caps))
Console.print("]; } ")
Emit.cname(v)
Console.print("_e = { ")
Emit.initCall(cx, fi, env, h, caps, args)
Console.print(", { ")
Emit.capArgs(env, caps, Emit.First)
Console.print(" } }; ")

def Emit.args {r: Region} (cx: Emit.Cx, fi: Emit.Fi, env: Emit.Env, xs: Coll.List[El.Expr], s: Emit.Sep): Unit = xs match
case Coll.Nil => ()
case Coll.Cons(x, rest) =>
Expand Down Expand Up @@ -631,15 +654,19 @@ def Emit.block {r: Region} (cx: Emit.Cx, fi: Emit.Fi, env: Emit.Env, pos: Emit.P
Emit.ex(cx, fi, env, Emit.Inner, e)
Console.print("; ")
Emit.block(cx, fi, Emit.bind(env, x), pos, rest, last, drops)
case El.Handle(_, x, h, args) =>
case El.Handle(_, x, h, caps, args) =>
val v = Emit.L(x, Emit.envN(env))
Emit.handleEnv(cx, fi, env, v, h, caps, args)
Console.print("srs_cap ")
Emit.cname(v)
Console.print("_v = { h_")
Emit.id(h)
Console.print("_init(")
Emit.args(cx, fi, env, args, Emit.First)
Console.print("), vt_")
Console.print("_v = { ")
caps match
case Coll.Nil => Emit.initCall(cx, fi, env, h, caps, args)
case Coll.Cons(_, _) =>
Console.print("&")
Emit.cname(v)
Console.print("_e")
Console.print(", vt_")
Emit.id(h)
Console.print(", 1 }; srs_cap* ")
Emit.cname(v)
Expand Down Expand Up @@ -705,7 +732,7 @@ def Emit.armsTail {r: Region} (cx: Emit.Cx, fi: Emit.Fi, as: Coll.List[El.Arm]):
def Emit.hasHandle(ss: Coll.List[El.Stmt]): Bool = ss match
case Coll.Nil => false
case Coll.Cons(s, rest) => s match
case El.Handle(_, _, _, _) => true
case El.Handle(_, _, _, _, _) => true
case _ => Emit.hasHandle(rest)

// ── an instance as the fn emit prints ──
Expand Down Expand Up @@ -840,7 +867,7 @@ def Emit.stmtsTys {r: Region} (cx: Emit.Cx, fi: Emit.Fi, ss: Coll.List[El.Stmt],
case Coll.Nil => acc
case Coll.Cons(s, rest) => s match
case El.Val(_, _, ty, _, e) => Emit.stmtsTys(cx, fi, rest, Emit.exTys(cx, fi, e, Coll.Cons(Emit.gr(cx, fi, ty), acc)))
case El.Handle(_, _, _, args) => Emit.stmtsTys(cx, fi, rest, Emit.exsTys(cx, fi, args, acc))
case El.Handle(_, _, _, _, args) => Emit.stmtsTys(cx, fi, rest, Emit.exsTys(cx, fi, args, acc))
case El.Do(e) => Emit.stmtsTys(cx, fi, rest, Emit.exTys(cx, fi, e, acc))

// the distinct enum terms of todo and of their fields, in the order found (seen: by hash bucket)
Expand Down Expand Up @@ -1039,29 +1066,88 @@ def Emit.implFns {r: Region} (cx: Emit.Cx, k: Emit.Kind, fs: Coll.List[El.Fn], w
def Emit.vtables {r: Region} (cx: Emit.Cx, hs: Coll.List[El.Handler]): Unit = hs match
case Coll.Nil => ()
case Coll.Cons(h, rest) =>
val El.Handler(hn, p, _) = h
val El.Handler(hn, p, fs) = h
val Emit.Cx(_, _, _, _, ps, _, _, _) = cx
val pre: Str = if Emit.hasRow(fs) then "w_" else "h_"
Emit.wrappers(cx, hn, fs)
Console.print("static void* const vt_")
Emit.id(hn)
Console.print("[] = {")
Coll.sLookup(ps, p) match
case Coll.Some(pr) =>
val Ast.Proto(_, _, _, _, _, _, ops, _) = pr
Emit.vtOps(hn, ops)
Emit.vtOps(pre, hn, ops)
case Coll.None => ()
Console.print(" 0 };\n")
Emit.vtables(cx, rest)

def Emit.vtOps(hn: Sym.Sym, ops: Coll.List[Ast.Op]): Unit = ops match
// a handler with a row (E1b): every fn takes the same implicit capabilities
def Emit.hasRow(fs: Coll.List[El.Fn]): Bool = fs match
case Coll.Nil => false
case Coll.Cons(f, _) =>
val El.Fn(_, _, _, caps, _, _, _) = f
Coll.length(caps) > 0

// its vtable entries: w_H_op(srs_env* e, args) calls h_H_op(e->c[0], .., e->st, args) (init is not in the vtable)
def Emit.wrappers {r: Region} (cx: Emit.Cx, hn: Sym.Sym, fs: Coll.List[El.Fn]): Unit = fs match
case Coll.Nil => ()
case Coll.Cons(f, rest) =>
val El.Fn(_, name, _, caps, _, _, _) = f
if Coll.length(caps) > 0 && !Str.eq(Sym.str(name), "init") then
val Emit.Fi(_, _, _, slots, ret) = Emit.fiOf(cx, Mono.Inst(f, Coll.Nil, Mono.Top))
Console.print("static ")
Emit.ctype(cx, ret)
Console.print(" w_")
Emit.id(hn)
Console.print("_")
Emit.id(name)
Console.print("(void* e_")
Emit.params(cx, Emit.opSlots(slots), Emit.Comma)
Console.print(") { srs_env* e = (srs_env*)e_; return h_")
Emit.id(hn)
Console.print("_")
Emit.id(name)
Console.print("(")
Emit.envCaps(0, Coll.length(caps))
Console.print("e->st")
Emit.slotArgs(Emit.opSlots(slots))
Console.print("); }\n")
else ()
Emit.wrappers(cx, hn, rest)

// the op's own params: no capability, no self
def Emit.opSlots(slots: Coll.List[Emit.Slot]): Coll.List[Emit.Slot] = slots match
case Coll.Nil => Coll.Nil
case Coll.Cons(s, rest) => s match
case Emit.SCap(_) => Emit.opSlots(rest)
case Emit.SVal(_, _) => rest

def Emit.envCaps(i: I64, n: I64): Unit =
if i < n then
Console.print("e->c[")
Console.printI64(i)
Console.print("], ")
Emit.envCaps(i + 1, n)
else ()

def Emit.slotArgs(slots: Coll.List[Emit.Slot]): Unit = slots match
case Coll.Nil => ()
case Coll.Cons(s, rest) =>
Console.print(", p_")
Emit.id(Emit.slotName(s))
Emit.slotArgs(rest)

def Emit.vtOps(pre: Str, hn: Sym.Sym, ops: Coll.List[Ast.Op]): Unit = ops match
case Coll.Nil => ()
case Coll.Cons(o, rest) =>
val Ast.Op(_, n, _, _, _) = o
Console.print(" (void*)h_")
Console.print(" (void*)")
Console.print(pre)
Emit.id(hn)
Console.print("_")
Emit.id(n)
Console.print(",")
Emit.vtOps(hn, rest)
Emit.vtOps(pre, hn, rest)

// the inline Arena bump (spec sec 5.2): the chunk layout of rt/srs_rt.c:24-25
def Emit.allocFast {r: Region} (cx: Emit.Cx): Unit =
Expand Down Expand Up @@ -1094,6 +1180,7 @@ def Emit.program {r: Region} (ds: Coll.List[Ast.Decl], res: Ty.Result): Unit =
Console.print("#include <stdint.h>\n#include <stdbool.h>\n#include <stddef.h>\n")
Console.print("typedef struct { const uint8_t* p; int64_t n; } srs_str;\n")
Console.print("typedef struct { void* self; void* const* vt; int64_t live; } srs_cap;\n")
Console.print("typedef struct { void* st; srs_cap* c[]; } srs_env;\n")
Console.print("void rt_init(int argc, char** argv);\n")
Emit.fwds(ens)
Emit.structs(cx, ens)
Expand Down
2 changes: 1 addition & 1 deletion s2/mono.srs
Original file line number Diff line number Diff line change
Expand Up @@ -228,5 +228,5 @@ def Mono.stmtCalls {r: Region} (s: Coll.IMap[K.Term], sub: Coll.List[Ty.Bind], x
val acc2 = x match
case El.Val(_, _, _, _, e) => Mono.calls(s, sub, e, acc)
case El.Do(e) => Mono.calls(s, sub, e, acc)
case El.Handle(_, _, _, args) => Mono.callsAll(s, sub, args, acc)
case El.Handle(_, _, _, _, args) => Mono.callsAll(s, sub, args, acc)
Mono.stmtCalls(s, sub, rest, acc2)
10 changes: 5 additions & 5 deletions s2/pure.srs
Original file line number Diff line number Diff line change
Expand Up @@ -114,23 +114,23 @@ def Pure.hprotos {r: Region} (ds: Coll.List[Ast.Decl], m: Coll.SMap[Sym.Sym]): C
Pure.hprotos(rest, Coll.sInsert(m, n, p))
case _ => Pure.hprotos(rest, m)

// a def's inferred row (s2/eff.srs) uses each of its protocols, as a written {} binder does
// a def's or a handler's inferred row (s2/eff.srs) uses each of its protocols, as a written {} binder does
def Pure.decls {r: Region} (ps: Coll.List[Sym.Sym], hp: Coll.SMap[Sym.Sym], rows: Eff.Rows, ds: Coll.List[Ast.Decl], acc: Coll.List[D.Fact]): Coll.List[D.Fact] = ds match
case Coll.Nil => acc
case Coll.Cons(d, rest) => d match
case Ast.DFn(f) =>
val Ast.Fn(_, n, _, _, _, _, _) = f
Pure.decls(ps, hp, rows, rest, Pure.rowUses(n, Eff.row(rows, n), Pure.fn(ps, hp, Pure.Def(n), f, acc)))
Pure.decls(ps, hp, rows, rest, Pure.rowUses(Pure.Def(n), Eff.row(rows, n), Pure.fn(ps, hp, Pure.Def(n), f, acc)))
case Ast.DHandler(h) =>
val Ast.Handler(_, n, p, fs) = h
Pure.decls(ps, hp, rows, rest, Pure.fns(ps, hp, Pure.In(n), fs, Coll.Cons(Pure.f2(Pure.RHandles, n, p), acc)))
Pure.decls(ps, hp, rows, rest, Pure.rowUses(Pure.In(n), Eff.row(rows, n), Pure.fns(ps, hp, Pure.In(n), fs, Coll.Cons(Pure.f2(Pure.RHandles, n, p), acc))))
case _ => Pure.decls(ps, hp, rows, rest, acc)

def Pure.rowUses {r: Region} (f: Sym.Sym, cs: Coll.List[Eff.Cap], acc: Coll.List[D.Fact]): Coll.List[D.Fact] = cs match
def Pure.rowUses {r: Region} (w: Pure.Who, cs: Coll.List[Eff.Cap], acc: Coll.List[D.Fact]): Coll.List[D.Fact] = cs match
case Coll.Nil => acc
case Coll.Cons(c, rest) =>
val Eff.Cap(p, _) = c
Pure.rowUses(f, rest, Coll.Cons(Pure.f2(Pure.RUses, f, p), acc))
Pure.rowUses(w, rest, Coll.Cons(Pure.f2(Pure.uses(w), Pure.subj(w), p), acc))

def Pure.fns {r: Region} (ps: Coll.List[Sym.Sym], hp: Coll.SMap[Sym.Sym], w: Pure.Who, fs: Coll.List[Ast.Fn], acc: Coll.List[D.Fact]): Coll.List[D.Fact] = fs match
case Coll.Nil => acc
Expand Down
20 changes: 12 additions & 8 deletions s2/types.srs
Original file line number Diff line number Diff line change
Expand Up @@ -553,10 +553,12 @@ def Ty.block {r: Region} (cx: Ty.Cx, st: Ty.St, bs: Coll.List[Ty.Bind], line: I6
case Coll.Cons(s, rest) => s match
case Ast.Val(sl, x, ann, e) => Ty.bindStmt(cx, st, bs, line, sl, x, ann, e, false, rest, last, want, acc)
case Ast.Var(sl, x, ann, e) => Ty.bindStmt(cx, st, bs, line, sl, x, ann, e, true, rest, last, want, acc)
// the handler's row takes the innermost capabilities outside this handle (E1b)
case Ast.Handle(sl, x, h, xs) =>
val Ty.Cx(_, _, _, hs, _, mode, _, _) = cx
val Ty.Cx(_, _, _, hs, _, mode, _, rows) = cx
val Ty.Es(st1, eargs) = Ty.exprs(cx, Ty.pureHandle(mode, st, sl, h), bs, xs, Coll.Nil)
Ty.block(cx, st1, Coll.Cons(Ty.Bind(x, K.Con(Ty.protoOf(hs, h), Coll.Nil)), bs), line, rest, last, want, Coll.Cons(El.Handle(sl, x, h, eargs), acc))
val Ty.Caps(st2, caps) = Ty.rowCaps(st1, bs, sl, Eff.row(rows, h), Coll.Nil)
Ty.block(cx, st2, Coll.Cons(Ty.Bind(x, K.Con(Ty.protoOf(hs, h), Coll.Nil)), bs), line, rest, last, want, Coll.Cons(El.Handle(sl, x, h, caps, eargs), acc))
case Ast.Do(e) =>
val Ty.Ex(st1, _, ee) = Ty.expr(cx, st, bs, e, Coll.None)
Ty.block(cx, st1, bs, line, rest, last, want, Coll.Cons(El.Do(ee), acc))
Expand Down Expand Up @@ -705,14 +707,16 @@ def Ty.decls {r: Region} (cx: Ty.Cx, st: Ty.St, ds: Coll.List[Ast.Decl], acc: Co
val Ty.Cx(_, _, _, _, _, _, _, rows) = cx
val Ty.FnEx(st1, ef) = Ty.fn(cx, st, f, Eff.row(rows, fname))
Ty.decls(cx, st1, rest, Coll.Cons(ef, acc), hacc, gacc)
// every fn of a handler takes the handler's row (E1b): the capabilities its handle site keeps
case Ast.DHandler(h) =>
val Ast.Handler(_, hn, p, fs) = h
val Ty.Fns(st1, efs, _, _) = Ty.fnsEl(cx, st, fs, Coll.Nil)
val Ty.Cx(_, _, _, _, _, _, _, rows) = cx
val Ty.Fns(st1, efs, _, _) = Ty.fnsEl(cx, st, fs, Eff.row(rows, hn), Coll.Nil)
Ty.decls(cx, st1, rest, acc, Coll.Cons(El.Handler(hn, p, efs), hacc), gacc)
// a given's fns see its binders: its [] binders are theirs, its {} evidence is local
case Ast.DGiven(g) =>
val Ast.Given(_, gs, head, fs) = g
val Ty.Fns(st1, efs, _, _) = Ty.fnsEl(cx, Ty.givenShape(cx, st, g), Ty.underGroups(gs, fs, Coll.Nil), Coll.Nil)
val Ty.Fns(st1, efs, _, _) = Ty.fnsEl(cx, Ty.givenShape(cx, st, g), Ty.underGroups(gs, fs, Coll.Nil), Coll.Nil, Coll.Nil)
val gv = El.Given(Ty.tparams(gs, Coll.Nil), Ty.binderNames(Ty.evidence(gs, Coll.Nil), Coll.Nil), Ty.term(head, Coll.Nil), efs)
Ty.decls(cx, st1, rest, acc, hacc, Coll.Cons(gv, gacc))
case _ => Ty.decls(cx, st, rest, acc, hacc, gacc)
Expand All @@ -729,12 +733,12 @@ def Ty.binderNames {r: Region} (bs: Coll.List[Ast.Binder], acc: Coll.List[Sym.Sy
val Ast.Binder(_, x, _) = b
Ty.binderNames(rest, Coll.Cons(x, acc))

// fns of a handler or given, elaborated in order
def Ty.fnsEl {r: Region} (cx: Ty.Cx, st: Ty.St, fs: Coll.List[Ast.Fn], acc: Coll.List[El.Fn]): Ty.Fns = fs match
// fns of a handler or given, elaborated in order, each with row
def Ty.fnsEl {r: Region} (cx: Ty.Cx, st: Ty.St, fs: Coll.List[Ast.Fn], row: Coll.List[Eff.Cap], acc: Coll.List[El.Fn]): Ty.Fns = fs match
case Coll.Nil => Ty.Fns(st, Coll.rev(acc), Coll.Nil, Coll.Nil)
case Coll.Cons(f, rest) =>
val Ty.FnEx(st1, ef) = Ty.fn(cx, st, f, Coll.Nil)
Ty.fnsEl(cx, st1, rest, Coll.Cons(ef, acc))
val Ty.FnEx(st1, ef) = Ty.fn(cx, st, f, row)
Ty.fnsEl(cx, st1, rest, row, Coll.Cons(ef, acc))

// an instance with a type arg that is still a var after the whole program: CannotInfer
def Ty.unsolved {r: Region} (s: Coll.IMap[K.Term], is: Coll.List[Ty.Inst], cs: Coll.List[Ty.Clash]): Coll.List[Ty.Clash] = is match
Expand Down
16 changes: 16 additions & 0 deletions tests/s2/neg/eff_handler_row.srs
Original file line number Diff line number Diff line change
@@ -0,0 +1,16 @@
// expect: error[unhandled-effect]
// a handler whose ops request Console needs a Console handler outside its handle
protocol Out:
state Live
start Live
end Live
op put(n: I64): Unit : Live -> Live

handler Std for Out:
def put(n: I64): Unit = Console.printI64(n)

def main(): I64 =
handle s = Std()
Out.put(1)
0
// expect: --> tests/s2/neg/eff_handler_row.srs:13
3 changes: 3 additions & 0 deletions tests/s2/prog/eff_handler_row.out
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
1
20
3
29 changes: 29 additions & 0 deletions tests/s2/prog/eff_handler_row.srs
Original file line number Diff line number Diff line change
@@ -0,0 +1,29 @@
// pass: E1b (vic 2026-11-09: kyo semantics, deep handlers): a handler op body may request effects; the handlers outside
// its handle answer them, captured when the handle runs. Tag requests Out inside its own put: Std answers, not Tag.
// viaStd opens Std itself: its row gets Console from Std's row
protocol Out:
state Live
start Live
end Live
op put(n: I64): Unit : Live -> Live

handler Std for Out:
def put(n: I64): Unit =
Console.printI64(n)
Console.print("\n")

handler Tag for Out:
def put(n: I64): Unit = Out.put(n * 10)

def viaStd(n: I64): Unit =
handle s = Std()
Out.put(n)

def main(): I64 =
handle c = Srs.Console()
handle s = Std()
Out.put(1)
handle t = Tag()
Out.put(2)
viaStd(3)
0
Loading
Loading