// ── FeatureMixingTests__Axis4_EmbeddedMethodPromoted_SatisfiesProtocol ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: FeatureMixingTests.cs::Axis4_EmbeddedMethodPromoted_SatisfiesProtocol   topic: interpolation   status: verified
// verified behavior: Test.run(...) == "hi kae"

namespace Test

data Greeter {
    name: string

    func describe() -> string {
        return "hi {self.name}"
    }
}

data Wrapped : IDescribable {
    Greeter
    tag: int
}

interface IDescribable {
    func describe() -> string
}

func report(d: IDescribable) -> string = d.describe()

func run() -> string {
    let w = Wrapped { name: "kae", tag: 1 }
    return report(w)
}

// ── ILEmitterTests__Protocol_RefDataImpl_CalledViaProtocolParameter_DispatchesVirtually ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests.cs::Protocol_RefDataImpl_CalledViaProtocolParameter_DispatchesVirtually   topic: interpolation   status: verified
// verified behavior: Test.goCat(...) == "cat:black"

namespace Test

interface INamed {
    func getName() -> string
}

ref data Dog : INamed {
    breed: string

    init(breed: string) {
        self.breed = breed
    }
}

func getName(self: Dog) -> string {
    return "dog:{self.breed}"
}

ref data Cat : INamed {
    color: string

    init(color: string) {
        self.color = color
    }
}

func getName(self: Cat) -> string {
    return "cat:{self.color}"
}

func describe(n: INamed) -> string {
    return n.getName()
}

func goDog() -> string {
    let d = Dog("lab")
    return describe(d)
}

func goCat() -> string {
    let c = Cat("black")
    return describe(c)
}

// ── ILEmitterTests__StringInterpolation_IL_Runtime ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests.cs::StringInterpolation_IL_Runtime   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func greet(name: string) -> string {
    return "hello {name}"
}

// ── ILEmitterTests__StringInterpolation_IntValue_IL_Runtime ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests.cs::StringInterpolation_IntValue_IL_Runtime   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func format(x: int) -> string {
    return "value: {x}"
}

// ── ILEmitterTests_Coverage_Adversarial__Interp_ChainedMemberAccess ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Adversarial.cs::Interp_ChainedMemberAccess   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

data Inner { v: int }
data Outer { inner: Inner }

func go() -> string {
    let o = Outer { inner: Inner { v: 42 } }
    return "got {o.inner.v}"
}

// ── ILEmitterTests_Coverage_Adversarial__Interp_EscapedBracesMixedWithHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Adversarial.cs::Interp_EscapedBracesMixedWithHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func go() -> string {
    let n = 7
    return "{{literal}} = {n}"
}

// ── ILEmitterTests_Coverage_Adversarial__Interp_MethodCallInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Adversarial.cs::Interp_MethodCallInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func square(n: int) -> int = n * n

func go() -> string = "sq={square(5)}"

// ── ILEmitterTests_Coverage_Adversarial__Interp_MultipleHolesAndOperators ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Adversarial.cs::Interp_MultipleHolesAndOperators   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func go() -> string {
    let a = 3
    let b = 4
    return "{a}+{b}={a + b}"
}

// ── ILEmitterTests_Coverage_Adversarial__Interp_ObjectLiteralInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Adversarial.cs::Interp_ObjectLiteralInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

data P { x: int, y: int }

func go() -> string = "p={P { x: 3, y: 4 }.x}"

// ── ILEmitterTests_Coverage_Adversarial__Interp_PropertyGetterHole_ValueTypeBoxes ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Adversarial.cs::Interp_PropertyGetterHole_ValueTypeBoxes   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func go() -> string {
    let s = "hello"
    return "len={s.Length}"
}

// ── ILEmitterTests_Coverage_Adversarial__Interp_TernaryWithNestedStringQuotes ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Adversarial.cs::Interp_TernaryWithNestedStringQuotes   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func go() -> string {
    let n = 0 - 3
    return "sign={n > 0 ? "+" : "-"}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_ArithmeticExpression ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_ArithmeticExpression   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "sum=7"

namespace Test
func go() -> string {
    let a = 3
    let b = 4
    return "sum={a + b}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_IntegerBoxing ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_IntegerBoxing   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "count=3"

namespace Test
func go() -> string {
    let n = 3
    return "count={n}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_LiteralBraces ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_LiteralBraces   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "{x}"

namespace Test
func go() -> string {
    return "{{x}}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_MemberAccess ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_MemberAccess   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "x=10"

namespace Test
data Pt { x: int, y: int }
func go() -> string {
    let p = Pt { x: 10, y: 20 }
    return "x={p.x}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_MethodCall ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_MethodCall   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "len=5"

namespace Test
func go() -> string {
    let s = "hello"
    return "len={s.Length}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_MultipleHoles ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_MultipleHoles   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "a1b2"

namespace Test
func go() -> string {
    let x = 1
    let y = 2
    return "a{x}b{y}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_SimpleVariable ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_SimpleVariable   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "hi alice"

namespace Test
func go() -> string {
    let name = "alice"
    return "hi {name}"
}

// ── ILEmitterTests_Coverage_Collections__Interp_TernaryInsideHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Interp_TernaryInsideHole   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "sign=+"

namespace Test
func go() -> string {
    let n = 5
    return "sign={n > 0 ? "+" : "-"}"
}

// ── ILEmitterTests_Coverage_Collections__Tuple_MixedTypes ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Collections.cs::Tuple_MixedTypes   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "alice:30"

namespace Test
func go() -> string {
    let t = ("alice", 30)
    return "{t.Item1}:{t.Item2}"
}

// ── ILEmitterTests_Coverage_Numerics__Int_ToStringInterpolation ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Coverage_Numerics.cs::Int_ToStringInterpolation   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "n=42"

namespace Test
func go() -> string {
    let n = 42
    return "n={n}"
}

// ── ILEmitterTests_Integration__Exe_MainProducesConsoleOutput ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Integration.cs::Exe_MainProducesConsoleOutput   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test

func main() -> int {
    let total = 7 * 6
    Console.WriteLine("answer={total}")
    return total
}

// ── ILEmitterTests_Integration__Reflection_FindsDeclaredMethod ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Integration.cs::Reflection_FindsDeclaredMethod   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Test
using "System.Reflection"
pub ref data Widget {
    id: int
    init(id: int) { self.id = id }
    pub func describe() -> string = "w{self.id}"
}
func go() -> bool {
    let w = Widget(1)
    let m = w.GetType().GetMethod("describe")
    return m != nil
}

// ── ILEmitterTests_Integration__Reflection_InvokeMethodDynamically ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Integration.cs::Reflection_InvokeMethodDynamically   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "w42"

namespace Test
using "System.Reflection"
pub ref data Widget {
    id: int
    init(id: int) { self.id = id }
    pub func describe() -> string = "w{self.id}"
}
func go() -> string {
    let w = Widget(42)
    let m = w.GetType().GetMethod("describe")
    let result = m.Invoke(w, nil)
    return result.ToString()
}

// ── ILEmitterTests_Interpolation__Added_CallInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::Added_CallInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func dbl(x: int) -> int = x * 2
func go() -> string {
  return "d={dbl(4)}"
}

// ── ILEmitterTests_Interpolation__Added_IndexInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::Added_IndexInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let xs = [9, 8]
  return "first={xs[0]}"
}

// ── ILEmitterTests_Interpolation__Added_MemberChainHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::Added_MemberChainHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

data P { x: int }
func go() -> string {
  let p = P { x: 5 }
  return "x={p.x}"
}

// ── ILEmitterTests_Interpolation__Added_PointerFieldHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::Added_PointerFieldHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

data B { n: int }
func go() -> string {
  let b = new B { n: 7 }
  return "n={b.n}"
}

// ── ILEmitterTests_Interpolation__AdditionOperator ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::AdditionOperator   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "sum={a + b}"
}

// ── ILEmitterTests_Interpolation__AdjacentHoles ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::AdjacentHoles   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "{a}{b}"
}

// ── ILEmitterTests_Interpolation__AndOperatorInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::AndOperatorInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = true
  let b = true
  return "both={a && b}"
}

// ── ILEmitterTests_Interpolation__BclFormatPlaceholderStaysLiteral ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::BclFormatPlaceholderStaysLiteral   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let x = 5
  return "{0} and {x}"
}

// ── ILEmitterTests_Interpolation__BoolHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::BoolHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let f = true
  return "flag={f}"
}

// ── ILEmitterTests_Interpolation__CallInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::CallInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func dbl(x: int) -> int = x * 2
func go() -> string {
  return "dbl={dbl(5)}"
}

// ── ILEmitterTests_Interpolation__CallWithArgExpression ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::CallWithArgExpression   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func add(a: int, b: int) -> int = a + b
func go() -> string {
  return "s={add(8, 12)}"
}

// ── ILEmitterTests_Interpolation__ChainedMemberInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::ChainedMemberInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

data Inner { v: int }
data Outer { inner: Inner }
func go() -> string {
  let o = Outer { inner: Inner { v: 7 } }
  return "inner={o.inner.v}"
}

// ── ILEmitterTests_Interpolation__ComparisonOperator ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::ComparisonOperator   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "lt={a < b}"
}

// ── ILEmitterTests_Interpolation__DivisionOperator ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::DivisionOperator   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 20
  let b = 4
  return "q={a / b}"
}

// ── ILEmitterTests_Interpolation__DoubleHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::DoubleHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let d = 1.5
  return "v={d}"
}

// ── ILEmitterTests_Interpolation__EmptyTextAroundSingleHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::EmptyTextAroundSingleHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let x = 9
  return "{x}"
}

// ── ILEmitterTests_Interpolation__HoleInLetThenReturn ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::HoleInLetThenReturn   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let n = 42
  let s = "got {n}"
  return s
}

// ── ILEmitterTests_Interpolation__IndexInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::IndexInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let xs = [10, 20, 30]
  return "first={xs[0]}"
}

// ── ILEmitterTests_Interpolation__LeadingAndTrailingText ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::LeadingAndTrailingText   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let x = 5
  return "[{x}]"
}

// ── ILEmitterTests_Interpolation__MemberChainInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::MemberChainInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

data P { name: string }
func go() -> string {
  let p = P { name: "kae" }
  return "n={p.name}"
}

// ── ILEmitterTests_Interpolation__MixedValueAndRefHoles ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::MixedValueAndRefHoles   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let name = "kae"
  let age = 30
  return "{name} is {age}"
}

// ── ILEmitterTests_Interpolation__ModuloInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::ModuloInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 7
  let b = 3
  return "mod={a % b}"
}

// ── ILEmitterTests_Interpolation__MultiplicationOperator ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::MultiplicationOperator   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "p={a * b}"
}

// ── ILEmitterTests_Interpolation__NegativeNumberHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::NegativeNumberHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let n = 0 - 7
  return "neg={n}"
}

// ── ILEmitterTests_Interpolation__NestedArithmetic ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::NestedArithmetic   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "r={a + b + b + b - 1 + 4 - 2 - 1}"
}

// ── ILEmitterTests_Interpolation__OrOperatorInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::OrOperatorInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = false
  let b = true
  return "any={a || b}"
}

// ── ILEmitterTests_Interpolation__PlainVariable ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::PlainVariable   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let x = 5
  return "x={x}"
}

// ── ILEmitterTests_Interpolation__StringHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::StringHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let who = "bob"
  return "hi {who}"
}

// ── ILEmitterTests_Interpolation__SubtractionOperator ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::SubtractionOperator   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "d={a - b}"
}

// ── ILEmitterTests_Interpolation__TernaryInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::TernaryInHole   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "max={a > b ? a : b}"
}

// ── ILEmitterTests_Interpolation__ThreeHolesArithmetic ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::ThreeHolesArithmetic   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 1
  let b = 2
  return "{a}+{b}={a + b}"
}

// ── ILEmitterTests_Interpolation__TwoHoles ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Interpolation.cs::TwoHoles   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

func go() -> string {
  let a = 3
  let b = 4
  return "{a} and {b}"
}

// ── ILEmitterTests_PtrEmbedIface__ValueEmbed_PromotedMethodThroughInterface ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_PtrEmbedIface.cs::ValueEmbed_PromotedMethodThroughInterface   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "hi kae"

data Greeter {
  name: string
  func describe() -> string { return "hi {self.name}" }
}


// ── ILEmitterTests2__String_Interpolation_Field_Access ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::String_Interpolation_Field_Access   topic: interpolation   status: verified
// verified behavior: Test.test(...) == "point 3,4"

namespace Test

data P { x: int, y: int }

func test() -> string {
    let p = P { x: 3, y: 4 }
    return "point {p.x},{p.y}"
}

// ── ILEmitterTests2__String_Interpolation_Single_Var ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::String_Interpolation_Single_Var   topic: interpolation   status: verified
// verified behavior: Test.test(...) == "n is 42"

namespace Test

func test(n: int) -> string = "n is {n}"

// ── ILEmitterTests2__String_Interpolation_Two_Variables ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::String_Interpolation_Two_Variables   topic: interpolation   status: verified
// verified behavior: Test.test(...) == "7:hello"

namespace Test

func test(a: int, b: string) -> string = "{a}:{b}"

// ── InterpolationBraceTests__HoleWithCall ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: InterpolationBraceTests.cs::HoleWithCall   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "squared=9"

namespace Test
func sq(n: int) -> int = n * n
func go() -> string {
    return "squared={sq(3)}"
}

// ── InterpolationBraceTests__InterpolationOnlyLocal_MemberAccessInHole ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: InterpolationBraceTests.cs::InterpolationOnlyLocal_MemberAccessInHole   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "3,4"

namespace Test
data P { x: int, y: int }
func go() -> string {
    let p = P { x: 3, y: 4 }
    return "{p.x},{p.y}"
}

// ── InterpolationBraceTests__JsonObjectBraces_WithInterpolatedField ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: InterpolationBraceTests.cs::JsonObjectBraces_WithInterpolatedField   topic: interpolation   status: verified
// verified behavior: Test.go(...) == "{\"k\":9}"

namespace Test
using "System.Text"
func go() -> string {
    let key = "k"
    let val = 9
    let sb = StringBuilder()
    sb.Append("{")
    sb.Append("\"{key}\":{val}")
    sb.Append("}")
    return sb.ToString()
}

// ── TranspilerTests__Transpiles_Function_Literal_Assigned_To_Variable ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: TranspilerTests.cs::Transpiles_Function_Literal_Assigned_To_Variable   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace FnVar

func run() {
    let greet = func(name: string) -> string {
        return "hello {name}"
    }
    Console.WriteLine(greet("world"))
}

// ── TranspilerTests__Transpiles_Protocol_And_Conformance ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: TranspilerTests.cs::Transpiles_Protocol_And_Conformance   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Greet

interface IGreeter {
    func greet(name: string) -> string
}

data Bot : IGreeter {
    prefix: string
}

func greet(b: Bot, name: string) -> string {
    return "{b.prefix} {name}"
}

// ── TranspilerTests__Transpiles_StringInterpolation ──
// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: TranspilerTests.cs::Transpiles_StringInterpolation   topic: interpolation   status: verified
// compiles cleanly (no auto-run claim was extracted)

namespace Greet

pub func hello(name: string) -> string {
    return "hello {name}"
}