print!(Foo)

(print!
  Foo)

( print!
  Foo )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: PushEffect("print")
00011: PushString("Foo")
00012: AppFnToArg
00013:   Return

"Foo"
[]

---

print!(Foo), print!(Bar), print!(FooBar)

(print!
  Foo)
(print!
  Bar)
(print!
  FooBar)

( =>
    ( =>
        ( print!
          FooBar )
      ( print!
        Bar ) )
  ( print!
    Foo ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: PushEffect("print")
00011: PushString("FooBar")
00012: AppFnToArg
00013:   Return
00014: LoadFn { code: 00010, fvars: 00000 }
00015: PushEffect("print")
00016: PushString("Bar")
00017: AppFnToArg
00018: AppFnToArg
00019:   Return
00020: LoadFn { code: 00014, fvars: 00000 }
00021: PushEffect("print")
00022: PushString("Foo")
00023: AppFnToArg
00024: AppFnToArg
00025:   Return

"Foo"
"Bar"
"FooBar"
[]

---

:foo = (:x => { :y => { pair!(Args(x, y)) } })
__handle({ foo(Bar, Baz) }, :r => { :eff => { :arg => { Pair(arg) } } })

(=
  :foo
  (=>
    :x
    { (=>
        :y
        { (pair!
            (Args
              x
              y)) }) }))
(__handle
  { (foo
      Bar
      Baz) }
  (=>
    :r
    { (=>
        :eff
        { (=>
            :arg
            { (Pair
                arg) }) }) }))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "foo" )
    ( ( =>
          =>
            0
        "x" )
      =>
        ( ( =>
              =>
                0
            "y" )
          =>
            ( pair!
              ( ( Args
                  1 )
                0 ) ) ) ) )
  =>
    ( ( =>
          =>
            ( try
              1
              0 )
        =>
          ( ( 1
              Bar )
            Baz ) )
      ( ( =>
            =>
              0
          "r" )
        =>
          ( ( =>
                =>
                  0
              "eff" )
            =>
              ( ( =>
                    =>
                      0
                  "arg" )
                =>
                  ( Pair
                    0 ) ) ) ) ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00000)
00011: LoadVar(00001)
00012: AppFnToArg
00013:   Return
00014: LoadFn { code: 00010, fvars: 00001 }
00015:   Return
00016: LoadFn { code: 00014, fvars: 00000 }
00017:   Return
00018: LoadVar(00000)
00019:   Return
00020: LoadFn { code: 00018, fvars: 00000 }
00021:   Return
00022: LoadVar(00000)
00023:   Return
00024: LoadFn { code: 00022, fvars: 00000 }
00025:   Return
00026: PushEffect("pair")
00027: PushString("Args")
00028: LoadVar(00001)
00029: AppFnToArg
00030: LoadVar(00000)
00031: AppFnToArg
00032: AppFnToArg
00033:   Return
00034: LoadFn { code: 00024, fvars: 00000 }
00035: PushString(""y"")
00036: AppFnToArg
00037: LoadFn { code: 00026, fvars: 00001 }
00038: AppFnToArg
00039:   Return
00040: LoadVar(00001)
00041: LoadVar(00000)
00042: Try
00043: AppArgToFn
00044: Unwind
00045: AppArgToFn
00046: AppArgToFn
00047: AppArgToFn
00048:   Return
00049: LoadFn { code: 00040, fvars: 00001 }
00050:   Return
00051: LoadVar(00001)
00052: PushString("Bar")
00053: AppFnToArg
00054: PushString("Baz")
00055: AppFnToArg
00056:   Return
00057: LoadVar(00000)
00058:   Return
00059: LoadFn { code: 00057, fvars: 00000 }
00060:   Return
00061: LoadVar(00000)
00062:   Return
00063: LoadFn { code: 00061, fvars: 00000 }
00064:   Return
00065: LoadVar(00000)
00066:   Return
00067: LoadFn { code: 00065, fvars: 00000 }
00068:   Return
00069: PushString("Pair")
00070: LoadVar(00000)
00071: AppFnToArg
00072:   Return
00073: LoadFn { code: 00067, fvars: 00000 }
00074: PushString(""arg"")
00075: AppFnToArg
00076: LoadFn { code: 00069, fvars: 00000 }
00077: AppFnToArg
00078:   Return
00079: LoadFn { code: 00063, fvars: 00000 }
00080: PushString(""eff"")
00081: AppFnToArg
00082: LoadFn { code: 00073, fvars: 00000 }
00083: AppFnToArg
00084:   Return
00085: LoadFn { code: 00049, fvars: 00000 }
00086: LoadFn { code: 00051, fvars: 00001 }
00087: AppFnToArg
00088: LoadFn { code: 00059, fvars: 00000 }
00089: PushString(""r"")
00090: AppFnToArg
00091: LoadFn { code: 00079, fvars: 00000 }
00092: AppFnToArg
00093: AppFnToArg
00094:   Return
00095: LoadFn { code: 00016, fvars: 00000 }
00096: PushString(""foo"")
00097: AppFnToArg
00098: LoadFn { code: 00020, fvars: 00000 }
00099: PushString(""x"")
00100: AppFnToArg
00101: LoadFn { code: 00034, fvars: 00000 }
00102: AppFnToArg
00103: AppFnToArg
00104: LoadFn { code: 00085, fvars: 00000 }
00105: AppFnToArg
00106:   Return

Pair(Args(Bar, Baz))

---

__handle({ Foo }, [:r, :eff, :arg] => { Error })

(__handle
  { Foo }
  (=>
    ([]
      :r
      :eff
      :arg)
    { Error }))

( ( =>
      =>
        ( try
          1
          0 )
    =>
      Foo )
  ( ( =>
        =>
          0
      ( ( ( []
            "r" )
          "eff" )
        "arg" ) )
    =>
      =>
        =>
          Error ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00001)
00011: LoadVar(00000)
00012: Try
00013: AppArgToFn
00014: Unwind
00015: AppArgToFn
00016: AppArgToFn
00017: AppArgToFn
00018:   Return
00019: LoadFn { code: 00010, fvars: 00001 }
00020:   Return
00021: PushString("Foo")
00022:   Return
00023: LoadVar(00000)
00024:   Return
00025: LoadFn { code: 00023, fvars: 00000 }
00026:   Return
00027: PushString("Error")
00028:   Return
00029: LoadFn { code: 00027, fvars: 00000 }
00030:   Return
00031: LoadFn { code: 00029, fvars: 00000 }
00032:   Return
00033: LoadFn { code: 00019, fvars: 00000 }
00034: LoadFn { code: 00021, fvars: 00000 }
00035: AppFnToArg
00036: LoadFn { code: 00025, fvars: 00000 }
00037: PushString("")
00038: PushString(""r"")
00039: AppFnToArg
00040: PushString(""eff"")
00041: AppFnToArg
00042: PushString(""arg"")
00043: AppFnToArg
00044: AppFnToArg
00045: LoadFn { code: 00031, fvars: 00000 }
00046: AppFnToArg
00047: AppFnToArg
00048:   Return

Foo

---

__handle({ effect!(Foo) }, [:r, :eff, :arg] => { arg(r(Bar)) })

(__handle
  { (effect!
      Foo) }
  (=>
    ([]
      :r
      :eff
      :arg)
    { (arg
        (r
          Bar)) }))

( ( =>
      =>
        ( try
          1
          0 )
    =>
      ( effect!
        Foo ) )
  ( ( =>
        =>
          0
      ( ( ( []
            "r" )
          "eff" )
        "arg" ) )
    =>
      =>
        =>
          ( 0
            ( 2
              Bar ) ) ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00001)
00011: LoadVar(00000)
00012: Try
00013: AppArgToFn
00014: Unwind
00015: AppArgToFn
00016: AppArgToFn
00017: AppArgToFn
00018:   Return
00019: LoadFn { code: 00010, fvars: 00001 }
00020:   Return
00021: PushEffect("effect")
00022: PushString("Foo")
00023: AppFnToArg
00024:   Return
00025: LoadVar(00000)
00026:   Return
00027: LoadFn { code: 00025, fvars: 00000 }
00028:   Return
00029: LoadVar(00000)
00030: LoadVar(00002)
00031: PushString("Bar")
00032: AppFnToArg
00033: AppFnToArg
00034:   Return
00035: LoadFn { code: 00029, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadFn { code: 00019, fvars: 00000 }
00040: LoadFn { code: 00021, fvars: 00000 }
00041: AppFnToArg
00042: LoadFn { code: 00027, fvars: 00000 }
00043: PushString("")
00044: PushString(""r"")
00045: AppFnToArg
00046: PushString(""eff"")
00047: AppFnToArg
00048: PushString(""arg"")
00049: AppFnToArg
00050: AppFnToArg
00051: LoadFn { code: 00037, fvars: 00000 }
00052: AppFnToArg
00053: AppFnToArg
00054:   Return

Foo(Bar)

---

__handle({
    Foo(eff!())
}, [:r, :eff, :arg] => {
    Pair(r(Bar), r(Baz))
})

(__handle
  { (Foo
      (eff!)) }
  (=>
    ([]
      :r
      :eff
      :arg)
    { (Pair
        (r
          Bar)
        (r
          Baz)) }))

( ( =>
      =>
        ( try
          1
          0 )
    =>
      ( Foo
        ( eff!
          [] ) ) )
  ( ( =>
        =>
          0
      ( ( ( []
            "r" )
          "eff" )
        "arg" ) )
    =>
      =>
        =>
          ( ( Pair
              ( 2
                Bar ) )
            ( 2
              Baz ) ) ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00001)
00011: LoadVar(00000)
00012: Try
00013: AppArgToFn
00014: Unwind
00015: AppArgToFn
00016: AppArgToFn
00017: AppArgToFn
00018:   Return
00019: LoadFn { code: 00010, fvars: 00001 }
00020:   Return
00021: PushString("Foo")
00022: PushEffect("eff")
00023: PushString("")
00024: AppFnToArg
00025: AppFnToArg
00026:   Return
00027: LoadVar(00000)
00028:   Return
00029: LoadFn { code: 00027, fvars: 00000 }
00030:   Return
00031: PushString("Pair")
00032: LoadVar(00002)
00033: PushString("Bar")
00034: AppFnToArg
00035: AppFnToArg
00036: LoadVar(00002)
00037: PushString("Baz")
00038: AppFnToArg
00039: AppFnToArg
00040:   Return
00041: LoadFn { code: 00031, fvars: 00002 }
00042:   Return
00043: LoadFn { code: 00041, fvars: 00001 }
00044:   Return
00045: LoadFn { code: 00019, fvars: 00000 }
00046: LoadFn { code: 00021, fvars: 00000 }
00047: AppFnToArg
00048: LoadFn { code: 00029, fvars: 00000 }
00049: PushString("")
00050: PushString(""r"")
00051: AppFnToArg
00052: PushString(""eff"")
00053: AppFnToArg
00054: PushString(""arg"")
00055: AppFnToArg
00056: AppFnToArg
00057: LoadFn { code: 00043, fvars: 00000 }
00058: AppFnToArg
00059: AppFnToArg
00060:   Return

Pair(Foo(Bar), Foo(Baz))

---

:foo = Foo
__handle({ List(elems!(foo)) }, [:r, :eff, :x] => { Twice(r(x, x), r(Baz)) })

(=
  :foo
  Foo)
(__handle
  { (List
      (elems!
        foo)) }
  (=>
    ([]
      :r
      :eff
      :x)
    { (Twice
        (r
          x
          x)
        (r
          Baz)) }))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "foo" )
    Foo )
  =>
    ( ( =>
          =>
            ( try
              1
              0 )
        =>
          ( List
            ( elems!
              1 ) ) )
      ( ( =>
            =>
              0
          ( ( ( []
                "r" )
              "eff" )
            "x" ) )
        =>
          =>
            =>
              ( ( Twice
                  ( ( 2
                      0 )
                    0 ) )
                ( 2
                  Baz ) ) ) ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00000)
00011: LoadVar(00001)
00012: AppFnToArg
00013:   Return
00014: LoadFn { code: 00010, fvars: 00001 }
00015:   Return
00016: LoadFn { code: 00014, fvars: 00000 }
00017:   Return
00018: LoadVar(00001)
00019: LoadVar(00000)
00020: Try
00021: AppArgToFn
00022: Unwind
00023: AppArgToFn
00024: AppArgToFn
00025: AppArgToFn
00026:   Return
00027: LoadFn { code: 00018, fvars: 00001 }
00028:   Return
00029: PushString("List")
00030: PushEffect("elems")
00031: LoadVar(00001)
00032: AppFnToArg
00033: AppFnToArg
00034:   Return
00035: LoadVar(00000)
00036:   Return
00037: LoadFn { code: 00035, fvars: 00000 }
00038:   Return
00039: PushString("Twice")
00040: LoadVar(00002)
00041: LoadVar(00000)
00042: AppFnToArg
00043: LoadVar(00000)
00044: AppFnToArg
00045: AppFnToArg
00046: LoadVar(00002)
00047: PushString("Baz")
00048: AppFnToArg
00049: AppFnToArg
00050:   Return
00051: LoadFn { code: 00039, fvars: 00002 }
00052:   Return
00053: LoadFn { code: 00051, fvars: 00001 }
00054:   Return
00055: LoadFn { code: 00027, fvars: 00000 }
00056: LoadFn { code: 00029, fvars: 00001 }
00057: AppFnToArg
00058: LoadFn { code: 00037, fvars: 00000 }
00059: PushString("")
00060: PushString(""r"")
00061: AppFnToArg
00062: PushString(""eff"")
00063: AppFnToArg
00064: PushString(""x"")
00065: AppFnToArg
00066: AppFnToArg
00067: LoadFn { code: 00053, fvars: 00000 }
00068: AppFnToArg
00069: AppFnToArg
00070:   Return
00071: LoadFn { code: 00016, fvars: 00000 }
00072: PushString(""foo"")
00073: AppFnToArg
00074: PushString("Foo")
00075: AppFnToArg
00076: LoadFn { code: 00055, fvars: 00000 }
00077: AppFnToArg
00078:   Return

Twice(List(Foo, Foo), List(Baz))

---

Foo(__handle({
  Baz(effect!(), effect!())
}, [:r, :eff, :arg] => {
    Bar(r(Qux))
}))

(Foo
  (__handle
    { (Baz
        (effect!)
        (effect!)) }
    (=>
      ([]
        :r
        :eff
        :arg)
      { (Bar
          (r
            Qux)) })))

( Foo
  ( ( =>
        =>
          ( try
            1
            0 )
      =>
        ( ( Baz
            ( effect!
              [] ) )
          ( effect!
            [] ) ) )
    ( ( =>
          =>
            0
        ( ( ( []
              "r" )
            "eff" )
          "arg" ) )
      =>
        =>
          =>
            ( Bar
              ( 2
                Qux ) ) ) ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00001)
00011: LoadVar(00000)
00012: Try
00013: AppArgToFn
00014: Unwind
00015: AppArgToFn
00016: AppArgToFn
00017: AppArgToFn
00018:   Return
00019: LoadFn { code: 00010, fvars: 00001 }
00020:   Return
00021: PushString("Baz")
00022: PushEffect("effect")
00023: PushString("")
00024: AppFnToArg
00025: AppFnToArg
00026: PushEffect("effect")
00027: PushString("")
00028: AppFnToArg
00029: AppFnToArg
00030:   Return
00031: LoadVar(00000)
00032:   Return
00033: LoadFn { code: 00031, fvars: 00000 }
00034:   Return
00035: PushString("Bar")
00036: LoadVar(00002)
00037: PushString("Qux")
00038: AppFnToArg
00039: AppFnToArg
00040:   Return
00041: LoadFn { code: 00035, fvars: 00002 }
00042:   Return
00043: LoadFn { code: 00041, fvars: 00001 }
00044:   Return
00045: PushString("Foo")
00046: LoadFn { code: 00019, fvars: 00000 }
00047: LoadFn { code: 00021, fvars: 00000 }
00048: AppFnToArg
00049: LoadFn { code: 00033, fvars: 00000 }
00050: PushString("")
00051: PushString(""r"")
00052: AppFnToArg
00053: PushString(""eff"")
00054: AppFnToArg
00055: PushString(""arg"")
00056: AppFnToArg
00057: AppFnToArg
00058: LoadFn { code: 00043, fvars: 00000 }
00059: AppFnToArg
00060: AppFnToArg
00061: AppFnToArg
00062:   Return

effect!([])

---

__handle({
  List(get!(), get!())
}, [:r, :eff, :arg] => {
    __handle({
      r(Foo)
    }, [:r, :eff, :arg] => {
        r(Bar)
    })
})

(__handle
  { (List
      (get!)
      (get!)) }
  (=>
    ([]
      :r
      :eff
      :arg)
    { (__handle
        { (r
            Foo) }
        (=>
          ([]
            :r
            :eff
            :arg)
          { (r
              Bar) })) }))

( ( =>
      =>
        ( try
          1
          0 )
    =>
      ( ( List
          ( get!
            [] ) )
        ( get!
          [] ) ) )
  ( ( =>
        =>
          0
      ( ( ( []
            "r" )
          "eff" )
        "arg" ) )
    =>
      =>
        =>
          ( ( =>
                =>
                  ( try
                    1
                    0 )
              =>
                ( 3
                  Foo ) )
            ( ( =>
                  =>
                    0
                ( ( ( []
                      "r" )
                    "eff" )
                  "arg" ) )
              =>
                =>
                  =>
                    ( 2
                      Bar ) ) ) ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00001)
00011: LoadVar(00000)
00012: Try
00013: AppArgToFn
00014: Unwind
00015: AppArgToFn
00016: AppArgToFn
00017: AppArgToFn
00018:   Return
00019: LoadFn { code: 00010, fvars: 00001 }
00020:   Return
00021: PushString("List")
00022: PushEffect("get")
00023: PushString("")
00024: AppFnToArg
00025: AppFnToArg
00026: PushEffect("get")
00027: PushString("")
00028: AppFnToArg
00029: AppFnToArg
00030:   Return
00031: LoadVar(00000)
00032:   Return
00033: LoadFn { code: 00031, fvars: 00000 }
00034:   Return
00035: LoadVar(00001)
00036: LoadVar(00000)
00037: Try
00038: AppArgToFn
00039: Unwind
00040: AppArgToFn
00041: AppArgToFn
00042: AppArgToFn
00043:   Return
00044: LoadFn { code: 00035, fvars: 00001 }
00045:   Return
00046: LoadVar(00003)
00047: PushString("Foo")
00048: AppFnToArg
00049:   Return
00050: LoadVar(00000)
00051:   Return
00052: LoadFn { code: 00050, fvars: 00000 }
00053:   Return
00054: LoadVar(00002)
00055: PushString("Bar")
00056: AppFnToArg
00057:   Return
00058: LoadFn { code: 00054, fvars: 00002 }
00059:   Return
00060: LoadFn { code: 00058, fvars: 00001 }
00061:   Return
00062: LoadFn { code: 00044, fvars: 00000 }
00063: LoadFn { code: 00046, fvars: 00003 }
00064: AppFnToArg
00065: LoadFn { code: 00052, fvars: 00000 }
00066: PushString("")
00067: PushString(""r"")
00068: AppFnToArg
00069: PushString(""eff"")
00070: AppFnToArg
00071: PushString(""arg"")
00072: AppFnToArg
00073: AppFnToArg
00074: LoadFn { code: 00060, fvars: 00000 }
00075: AppFnToArg
00076: AppFnToArg
00077:   Return
00078: LoadFn { code: 00062, fvars: 00002 }
00079:   Return
00080: LoadFn { code: 00078, fvars: 00001 }
00081:   Return
00082: LoadFn { code: 00019, fvars: 00000 }
00083: LoadFn { code: 00021, fvars: 00000 }
00084: AppFnToArg
00085: LoadFn { code: 00033, fvars: 00000 }
00086: PushString("")
00087: PushString(""r"")
00088: AppFnToArg
00089: PushString(""eff"")
00090: AppFnToArg
00091: PushString(""arg"")
00092: AppFnToArg
00093: AppFnToArg
00094: LoadFn { code: 00080, fvars: 00000 }
00095: AppFnToArg
00096: AppFnToArg
00097:   Return

List(Foo, Bar)

---

__handle({
    __handle({ throw!() }, [:r, :eff, :arg] => { })
    throw!()
}, [:r, :eff, :arg] => { })

(__handle
  { (__handle
      { (throw!) }
      (=>
        ([]
          :r
          :eff
          :arg)
        {  }))
    (throw!) }
  (=>
    ([]
      :r
      :eff
      :arg)
    {  }))

( ( =>
      =>
        ( try
          1
          0 )
    =>
      ( =>
          ( throw!
            [] )
        ( ( =>
              =>
                ( try
                  1
                  0 )
            =>
              ( throw!
                [] ) )
          ( ( =>
                =>
                  0
              ( ( ( []
                    "r" )
                  "eff" )
                "arg" ) )
            =>
              =>
                =>
                  [] ) ) ) )
  ( ( =>
        =>
          0
      ( ( ( []
            "r" )
          "eff" )
        "arg" ) )
    =>
      =>
        =>
          [] ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00001)
00011: LoadVar(00000)
00012: Try
00013: AppArgToFn
00014: Unwind
00015: AppArgToFn
00016: AppArgToFn
00017: AppArgToFn
00018:   Return
00019: LoadFn { code: 00010, fvars: 00001 }
00020:   Return
00021: PushEffect("throw")
00022: PushString("")
00023: AppFnToArg
00024:   Return
00025: LoadVar(00001)
00026: LoadVar(00000)
00027: Try
00028: AppArgToFn
00029: Unwind
00030: AppArgToFn
00031: AppArgToFn
00032: AppArgToFn
00033:   Return
00034: LoadFn { code: 00025, fvars: 00001 }
00035:   Return
00036: PushEffect("throw")
00037: PushString("")
00038: AppFnToArg
00039:   Return
00040: LoadVar(00000)
00041:   Return
00042: LoadFn { code: 00040, fvars: 00000 }
00043:   Return
00044: PushString("")
00045:   Return
00046: LoadFn { code: 00044, fvars: 00000 }
00047:   Return
00048: LoadFn { code: 00046, fvars: 00000 }
00049:   Return
00050: LoadFn { code: 00021, fvars: 00000 }
00051: LoadFn { code: 00034, fvars: 00000 }
00052: LoadFn { code: 00036, fvars: 00000 }
00053: AppFnToArg
00054: LoadFn { code: 00042, fvars: 00000 }
00055: PushString("")
00056: PushString(""r"")
00057: AppFnToArg
00058: PushString(""eff"")
00059: AppFnToArg
00060: PushString(""arg"")
00061: AppFnToArg
00062: AppFnToArg
00063: LoadFn { code: 00048, fvars: 00000 }
00064: AppFnToArg
00065: AppFnToArg
00066: AppFnToArg
00067:   Return
00068: LoadVar(00000)
00069:   Return
00070: LoadFn { code: 00068, fvars: 00000 }
00071:   Return
00072: PushString("")
00073:   Return
00074: LoadFn { code: 00072, fvars: 00000 }
00075:   Return
00076: LoadFn { code: 00074, fvars: 00000 }
00077:   Return
00078: LoadFn { code: 00019, fvars: 00000 }
00079: LoadFn { code: 00050, fvars: 00000 }
00080: AppFnToArg
00081: LoadFn { code: 00070, fvars: 00000 }
00082: PushString("")
00083: PushString(""r"")
00084: AppFnToArg
00085: PushString(""eff"")
00086: AppFnToArg
00087: PushString(""arg"")
00088: AppFnToArg
00089: AppFnToArg
00090: LoadFn { code: 00076, fvars: 00000 }
00091: AppFnToArg
00092: AppFnToArg
00093:   Return

[]

---

:x = load!("[Foo, Bar]")
Pair(x, x)

(=
  :x
  (load!
    "[Foo, Bar]"))
(Pair
  x
  x)

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "x" )
    ( load!
      "[Foo, Bar]" ) )
  =>
    ( ( Pair
        0 )
      0 ) )

00000: LoadFn { code: 00002, fvars: 00001 }
00001:   Return
00002: LoadVar(00000)
00003: LoadVar(00001)
00004: LoadFn { code: 00000, fvars: 00000 }
00005: AppArgToFn
00006: LoadVar(00001)
00007: AppArgToFn
00008: AppArgToFn
00009:   Return
00010: LoadVar(00000)
00011: LoadVar(00001)
00012: AppFnToArg
00013:   Return
00014: LoadFn { code: 00010, fvars: 00001 }
00015:   Return
00016: LoadFn { code: 00014, fvars: 00000 }
00017:   Return
00018: PushString("Pair")
00019: LoadVar(00000)
00020: AppFnToArg
00021: LoadVar(00000)
00022: AppFnToArg
00023:   Return
00024: LoadFn { code: 00016, fvars: 00000 }
00025: PushString(""x"")
00026: AppFnToArg
00027: PushEffect("load")
00028: PushString(""[Foo, Bar]"")
00029: AppFnToArg
00030: AppFnToArg
00031: LoadFn { code: 00018, fvars: 00000 }
00032: AppFnToArg
00033:   Return

Pair([Foo, Bar], [Foo, Bar])