(:acc => {
    __handle({
        effect!(Foo)
    }, [:r, :eff, :x] => {
        r(acc(x))
    })
})(List)

((=>
  :acc
  { (__handle
      { (effect!
          Foo) }
      (=>
        ([]
          :r
          :eff
          :x)
        { (r
            (acc
              x)) })) })
  List)

( ( ( =>
        =>
          0
      "acc" )
    =>
      ( ( =>
            =>
              ( try
                1
                0 )
          =>
            ( effect!
              Foo ) )
        ( ( =>
              =>
                0
            ( ( ( []
                  "r" )
                "eff" )
              "x" ) )
          =>
            =>
              =>
                ( 2
                  ( 3
                    0 ) ) ) ) )
  List )

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:   Return
00012: LoadFn { code: 00010, fvars: 00000 }
00013:   Return
00014: LoadVar(00001)
00015: LoadVar(00000)
00016: Try
00017: AppArgToFn
00018: Unwind
00019: AppArgToFn
00020: AppArgToFn
00021: AppArgToFn
00022:   Return
00023: LoadFn { code: 00014, fvars: 00001 }
00024:   Return
00025: PushEffect("effect")
00026: PushString("Foo")
00027: AppFnToArg
00028:   Return
00029: LoadVar(00000)
00030:   Return
00031: LoadFn { code: 00029, fvars: 00000 }
00032:   Return
00033: LoadVar(00002)
00034: LoadVar(00003)
00035: LoadVar(00000)
00036: AppFnToArg
00037: AppFnToArg
00038:   Return
00039: LoadFn { code: 00033, fvars: 00003 }
00040:   Return
00041: LoadFn { code: 00039, fvars: 00002 }
00042:   Return
00043: LoadFn { code: 00023, fvars: 00000 }
00044: LoadFn { code: 00025, fvars: 00000 }
00045: AppFnToArg
00046: LoadFn { code: 00031, fvars: 00000 }
00047: PushString("")
00048: PushString(""r"")
00049: AppFnToArg
00050: PushString(""eff"")
00051: AppFnToArg
00052: PushString(""x"")
00053: AppFnToArg
00054: AppFnToArg
00055: LoadFn { code: 00041, fvars: 00001 }
00056: AppFnToArg
00057: AppFnToArg
00058:   Return
00059: LoadFn { code: 00012, fvars: 00000 }
00060: PushString(""acc"")
00061: AppFnToArg
00062: LoadFn { code: 00043, fvars: 00000 }
00063: AppFnToArg
00064: PushString("List")
00065: AppFnToArg
00066:   Return

List(Foo)

---

:with-toggle = (:loop ~> {
    :val => { :r => {
        __handle({
            r(val)
        }, [:r, :eff, :arg] => {
            __compare(val, True, {
              loop(False, r)
            }, {
              loop(True, r)
            })
        })
    }}
})
with-toggle(False, { List(toggle!(), toggle!(), toggle!()) })

(=
  :with-toggle
  (~>
    :loop
    { (=>
        :val
        { (=>
            :r
            { (__handle
                { (r
                    val) }
                (=>
                  ([]
                    :r
                    :eff
                    :arg)
                  { (__compare
                      val
                      True
                      { (loop
                          False
                          r) }
                      { (loop
                          True
                          r) }) })) }) }) }))
(with-toggle
  False
  { (List
      (toggle!)
      (toggle!)
      (toggle!)) })

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "with-toggle" )
    ( ( =>
          =>
            ~>
              0
        "loop" )
      =>
        ( ( =>
              =>
                0
            "val" )
          =>
            ( ( =>
                  =>
                    0
                "r" )
              =>
                ( ( =>
                      =>
                        ( try
                          1
                          0 )
                    =>
                      ( 1
                        2 ) )
                  ( ( =>
                        =>
                          0
                      ( ( ( []
                            "r" )
                          "eff" )
                        "arg" ) )
                    =>
                      =>
                        =>
                          ( ( ( ( =>
                                    =>
                                      =>
                                        =>
                                          ( if
                                            3
                                            2
                                            1
                                            0 )
                                  4 )
                                True )
                              =>
                                ( ( 6
                                    False )
                                  3 ) )
                            =>
                              ( ( 6
                                  True )
                                3 ) ) ) ) ) ) ) )
  =>
    ( ( 0
        False )
      =>
        ( ( ( List
              ( toggle!
                [] ) )
            ( toggle!
              [] ) )
          ( toggle!
            [] ) ) ) )

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: LoadFn { code: 00000, fvars: 00000 }
00020: AppArgToFn
00021:   Return
00022: LoadFn { code: 00018, fvars: 00000 }
00023:   Return
00024: LoadVar(00000)
00025:   Return
00026: LoadFn { code: 00024, fvars: 00000 }
00027:   Return
00028: LoadVar(00000)
00029:   Return
00030: LoadFn { code: 00028, fvars: 00000 }
00031:   Return
00032: LoadVar(00001)
00033: LoadVar(00000)
00034: Try
00035: AppArgToFn
00036: Unwind
00037: AppArgToFn
00038: AppArgToFn
00039: AppArgToFn
00040:   Return
00041: LoadFn { code: 00032, fvars: 00001 }
00042:   Return
00043: LoadVar(00001)
00044: LoadVar(00002)
00045: AppFnToArg
00046:   Return
00047: LoadVar(00000)
00048:   Return
00049: LoadFn { code: 00047, fvars: 00000 }
00050:   Return
00051: LoadVar(00003)
00052: LoadVar(00002)
00053: LoadVar(00001)
00054: LoadVar(00000)
00055: Compare
00056: AppArgToFn
00057:   Return
00058: LoadFn { code: 00051, fvars: 00003 }
00059:   Return
00060: LoadFn { code: 00058, fvars: 00002 }
00061:   Return
00062: LoadFn { code: 00060, fvars: 00001 }
00063:   Return
00064: LoadVar(00006)
00065: PushString("False")
00066: AppFnToArg
00067: LoadVar(00003)
00068: AppFnToArg
00069:   Return
00070: LoadVar(00006)
00071: PushString("True")
00072: AppFnToArg
00073: LoadVar(00003)
00074: AppFnToArg
00075:   Return
00076: LoadFn { code: 00062, fvars: 00000 }
00077: LoadVar(00004)
00078: AppFnToArg
00079: PushString("True")
00080: AppFnToArg
00081: LoadFn { code: 00064, fvars: 00006 }
00082: AppFnToArg
00083: LoadFn { code: 00070, fvars: 00006 }
00084: AppFnToArg
00085:   Return
00086: LoadFn { code: 00076, fvars: 00005 }
00087:   Return
00088: LoadFn { code: 00086, fvars: 00004 }
00089:   Return
00090: LoadFn { code: 00041, fvars: 00000 }
00091: LoadFn { code: 00043, fvars: 00002 }
00092: AppFnToArg
00093: LoadFn { code: 00049, fvars: 00000 }
00094: PushString("")
00095: PushString(""r"")
00096: AppFnToArg
00097: PushString(""eff"")
00098: AppFnToArg
00099: PushString(""arg"")
00100: AppFnToArg
00101: AppFnToArg
00102: LoadFn { code: 00088, fvars: 00003 }
00103: AppFnToArg
00104: AppFnToArg
00105:   Return
00106: LoadFn { code: 00030, fvars: 00000 }
00107: PushString(""r"")
00108: AppFnToArg
00109: LoadFn { code: 00090, fvars: 00002 }
00110: AppFnToArg
00111:   Return
00112: LoadFn { code: 00026, fvars: 00000 }
00113: PushString(""val"")
00114: AppFnToArg
00115: LoadFn { code: 00106, fvars: 00001 }
00116: AppFnToArg
00117:   Return
00118: PushString("List")
00119: PushEffect("toggle")
00120: PushString("")
00121: AppFnToArg
00122: AppFnToArg
00123: PushEffect("toggle")
00124: PushString("")
00125: AppFnToArg
00126: AppFnToArg
00127: PushEffect("toggle")
00128: PushString("")
00129: AppFnToArg
00130: AppFnToArg
00131:   Return
00132: LoadVar(00000)
00133: PushString("False")
00134: AppFnToArg
00135: LoadFn { code: 00118, fvars: 00000 }
00136: AppFnToArg
00137:   Return
00138: LoadFn { code: 00016, fvars: 00000 }
00139: PushString(""with-toggle"")
00140: AppFnToArg
00141: LoadFn { code: 00022, fvars: 00000 }
00142: PushString(""loop"")
00143: AppFnToArg
00144: LoadFn { code: 00112, fvars: 00000 }
00145: AppFnToArg
00146: AppFnToArg
00147: LoadFn { code: 00132, fvars: 00000 }
00148: AppFnToArg
00149:   Return

List(True, False, True)