:fold = (:fold ~> { [:f, :acc, :xs] => {
    __unpack(xs, [:xs, :x] => {
        fold(f, f(acc, x), xs)
    }, {
        acc
    })
}})
fold([:acc, :x] => { acc(x) }, [], [A, B, C])

(=
  :fold
  (~>
    :fold
    { (=>
        ([]
          :f
          :acc
          :xs)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (fold
                  f
                  (f
                    acc
                    x)
                  xs) })
            { acc }) }) }))
(fold
  (=>
    ([]
      :acc
      :x)
    { (acc
        x) })
  []
  ([]
    A
    B
    C))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "fold" )
    ( ( =>
          =>
            ~>
              0
        "fold" )
      =>
        ( ( =>
              =>
                0
            ( ( ( []
                  "f" )
                "acc" )
              "xs" ) )
          =>
            =>
              =>
                ( ( ( =>
                        =>
                          =>
                            ( pop
                              2
                              1
                              0 )
                      0 )
                    ( ( =>
                          =>
                            0
                        ( ( []
                            "xs" )
                          "x" ) )
                      =>
                        =>
                          ( ( ( 5
                                4 )
                              ( ( 4
                                  3 )
                                0 ) )
                            1 ) ) )
                  =>
                    2 ) ) ) )
  =>
    ( ( ( 0
          ( ( =>
                =>
                  0
              ( ( []
                  "acc" )
                "x" ) )
            =>
              =>
                ( 1
                  0 ) ) )
        [] )
      ( ( ( []
            A )
          B )
        C ) ) )

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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00005)
00044: LoadVar(00004)
00045: AppFnToArg
00046: LoadVar(00004)
00047: LoadVar(00003)
00048: AppFnToArg
00049: LoadVar(00000)
00050: AppFnToArg
00051: AppFnToArg
00052: LoadVar(00001)
00053: AppFnToArg
00054:   Return
00055: LoadFn { code: 00043, fvars: 00005 }
00056:   Return
00057: LoadVar(00002)
00058:   Return
00059: LoadFn { code: 00037, fvars: 00000 }
00060: LoadVar(00000)
00061: AppFnToArg
00062: LoadFn { code: 00041, fvars: 00000 }
00063: PushString("")
00064: PushString(""xs"")
00065: AppFnToArg
00066: PushString(""x"")
00067: AppFnToArg
00068: AppFnToArg
00069: LoadFn { code: 00055, fvars: 00004 }
00070: AppFnToArg
00071: AppFnToArg
00072: LoadFn { code: 00057, fvars: 00002 }
00073: AppFnToArg
00074:   Return
00075: LoadFn { code: 00059, fvars: 00003 }
00076:   Return
00077: LoadFn { code: 00075, fvars: 00002 }
00078:   Return
00079: LoadFn { code: 00026, fvars: 00000 }
00080: PushString("")
00081: PushString(""f"")
00082: AppFnToArg
00083: PushString(""acc"")
00084: AppFnToArg
00085: PushString(""xs"")
00086: AppFnToArg
00087: AppFnToArg
00088: LoadFn { code: 00077, fvars: 00001 }
00089: AppFnToArg
00090:   Return
00091: LoadVar(00000)
00092:   Return
00093: LoadFn { code: 00091, fvars: 00000 }
00094:   Return
00095: LoadVar(00001)
00096: LoadVar(00000)
00097: AppFnToArg
00098:   Return
00099: LoadFn { code: 00095, fvars: 00001 }
00100:   Return
00101: LoadVar(00000)
00102: LoadFn { code: 00093, fvars: 00000 }
00103: PushString("")
00104: PushString(""acc"")
00105: AppFnToArg
00106: PushString(""x"")
00107: AppFnToArg
00108: AppFnToArg
00109: LoadFn { code: 00099, fvars: 00000 }
00110: AppFnToArg
00111: AppFnToArg
00112: PushString("")
00113: AppFnToArg
00114: PushString("")
00115: PushString("A")
00116: AppFnToArg
00117: PushString("B")
00118: AppFnToArg
00119: PushString("C")
00120: AppFnToArg
00121: AppFnToArg
00122:   Return
00123: LoadFn { code: 00016, fvars: 00000 }
00124: PushString(""fold"")
00125: AppFnToArg
00126: LoadFn { code: 00022, fvars: 00000 }
00127: PushString(""fold"")
00128: AppFnToArg
00129: LoadFn { code: 00079, fvars: 00000 }
00130: AppFnToArg
00131: AppFnToArg
00132: LoadFn { code: 00101, fvars: 00000 }
00133: AppFnToArg
00134:   Return

[C, B, A]

---

:fold = (:fold ~> { [:f, :acc, :xs] => {
    __unpack(xs, [:xs, :x] => {
        fold(f, f(acc, x), xs)
    }, {
        acc
    })
}})
:reverse = (:xs => {
    fold([:xs, :x] => { xs(x) }, [], xs)
})
reverse([A, B, C])

(=
  :fold
  (~>
    :fold
    { (=>
        ([]
          :f
          :acc
          :xs)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (fold
                  f
                  (f
                    acc
                    x)
                  xs) })
            { acc }) }) }))
(=
  :reverse
  (=>
    :xs
    { (fold
        (=>
          ([]
            :xs
            :x)
          { (xs
              x) })
        []
        xs) }))
(reverse
  ([]
    A
    B
    C))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "fold" )
    ( ( =>
          =>
            ~>
              0
        "fold" )
      =>
        ( ( =>
              =>
                0
            ( ( ( []
                  "f" )
                "acc" )
              "xs" ) )
          =>
            =>
              =>
                ( ( ( =>
                        =>
                          =>
                            ( pop
                              2
                              1
                              0 )
                      0 )
                    ( ( =>
                          =>
                            0
                        ( ( []
                            "xs" )
                          "x" ) )
                      =>
                        =>
                          ( ( ( 5
                                4 )
                              ( ( 4
                                  3 )
                                0 ) )
                            1 ) ) )
                  =>
                    2 ) ) ) )
  =>
    ( ( ( =>
            =>
              =>
                ( 0
                  1 )
          "reverse" )
        ( ( =>
              =>
                0
            "xs" )
          =>
            ( ( ( 1
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "xs" )
                        "x" ) )
                    =>
                      =>
                        ( 1
                          0 ) ) )
                [] )
              0 ) ) )
      =>
        ( 0
          ( ( ( []
                A )
              B )
            C ) ) ) )

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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00005)
00044: LoadVar(00004)
00045: AppFnToArg
00046: LoadVar(00004)
00047: LoadVar(00003)
00048: AppFnToArg
00049: LoadVar(00000)
00050: AppFnToArg
00051: AppFnToArg
00052: LoadVar(00001)
00053: AppFnToArg
00054:   Return
00055: LoadFn { code: 00043, fvars: 00005 }
00056:   Return
00057: LoadVar(00002)
00058:   Return
00059: LoadFn { code: 00037, fvars: 00000 }
00060: LoadVar(00000)
00061: AppFnToArg
00062: LoadFn { code: 00041, fvars: 00000 }
00063: PushString("")
00064: PushString(""xs"")
00065: AppFnToArg
00066: PushString(""x"")
00067: AppFnToArg
00068: AppFnToArg
00069: LoadFn { code: 00055, fvars: 00004 }
00070: AppFnToArg
00071: AppFnToArg
00072: LoadFn { code: 00057, fvars: 00002 }
00073: AppFnToArg
00074:   Return
00075: LoadFn { code: 00059, fvars: 00003 }
00076:   Return
00077: LoadFn { code: 00075, fvars: 00002 }
00078:   Return
00079: LoadFn { code: 00026, fvars: 00000 }
00080: PushString("")
00081: PushString(""f"")
00082: AppFnToArg
00083: PushString(""acc"")
00084: AppFnToArg
00085: PushString(""xs"")
00086: AppFnToArg
00087: AppFnToArg
00088: LoadFn { code: 00077, fvars: 00001 }
00089: AppFnToArg
00090:   Return
00091: LoadVar(00000)
00092: LoadVar(00001)
00093: AppFnToArg
00094:   Return
00095: LoadFn { code: 00091, fvars: 00001 }
00096:   Return
00097: LoadFn { code: 00095, fvars: 00000 }
00098:   Return
00099: LoadVar(00000)
00100:   Return
00101: LoadFn { code: 00099, fvars: 00000 }
00102:   Return
00103: LoadVar(00000)
00104:   Return
00105: LoadFn { code: 00103, fvars: 00000 }
00106:   Return
00107: LoadVar(00001)
00108: LoadVar(00000)
00109: AppFnToArg
00110:   Return
00111: LoadFn { code: 00107, fvars: 00001 }
00112:   Return
00113: LoadVar(00001)
00114: LoadFn { code: 00105, fvars: 00000 }
00115: PushString("")
00116: PushString(""xs"")
00117: AppFnToArg
00118: PushString(""x"")
00119: AppFnToArg
00120: AppFnToArg
00121: LoadFn { code: 00111, fvars: 00000 }
00122: AppFnToArg
00123: AppFnToArg
00124: PushString("")
00125: AppFnToArg
00126: LoadVar(00000)
00127: AppFnToArg
00128:   Return
00129: LoadVar(00000)
00130: PushString("")
00131: PushString("A")
00132: AppFnToArg
00133: PushString("B")
00134: AppFnToArg
00135: PushString("C")
00136: AppFnToArg
00137: AppFnToArg
00138:   Return
00139: LoadFn { code: 00097, fvars: 00000 }
00140: PushString(""reverse"")
00141: AppFnToArg
00142: LoadFn { code: 00101, fvars: 00000 }
00143: PushString(""xs"")
00144: AppFnToArg
00145: LoadFn { code: 00113, fvars: 00001 }
00146: AppFnToArg
00147: AppFnToArg
00148: LoadFn { code: 00129, fvars: 00000 }
00149: AppFnToArg
00150:   Return
00151: LoadFn { code: 00016, fvars: 00000 }
00152: PushString(""fold"")
00153: AppFnToArg
00154: LoadFn { code: 00022, fvars: 00000 }
00155: PushString(""fold"")
00156: AppFnToArg
00157: LoadFn { code: 00079, fvars: 00000 }
00158: AppFnToArg
00159: AppFnToArg
00160: LoadFn { code: 00139, fvars: 00000 }
00161: AppFnToArg
00162:   Return

[C, B, A]

---

:fold = (:fold ~> { [:f, :acc, :xs] => {
    __unpack(xs, [:xs, :x] => {
        fold(f, f(acc, x), xs)
    }, {
        acc
    })
}})
:reverse = (:xs => {
    fold([:xs, :x] => { xs(x) }, [], xs)
})
:apply = ([:f, :xs] => {
    fold([:f, :x] => { f(x) }, f, reverse(xs))
})
apply([:x, :y, :z] => { Triple(x, y, z) }, [A, B, C])

(=
  :fold
  (~>
    :fold
    { (=>
        ([]
          :f
          :acc
          :xs)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (fold
                  f
                  (f
                    acc
                    x)
                  xs) })
            { acc }) }) }))
(=
  :reverse
  (=>
    :xs
    { (fold
        (=>
          ([]
            :xs
            :x)
          { (xs
              x) })
        []
        xs) }))
(=
  :apply
  (=>
    ([]
      :f
      :xs)
    { (fold
        (=>
          ([]
            :f
            :x)
          { (f
              x) })
        f
        (reverse
          xs)) }))
(apply
  (=>
    ([]
      :x
      :y
      :z)
    { (Triple
        x
        y
        z) })
  ([]
    A
    B
    C))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "fold" )
    ( ( =>
          =>
            ~>
              0
        "fold" )
      =>
        ( ( =>
              =>
                0
            ( ( ( []
                  "f" )
                "acc" )
              "xs" ) )
          =>
            =>
              =>
                ( ( ( =>
                        =>
                          =>
                            ( pop
                              2
                              1
                              0 )
                      0 )
                    ( ( =>
                          =>
                            0
                        ( ( []
                            "xs" )
                          "x" ) )
                      =>
                        =>
                          ( ( ( 5
                                4 )
                              ( ( 4
                                  3 )
                                0 ) )
                            1 ) ) )
                  =>
                    2 ) ) ) )
  =>
    ( ( ( =>
            =>
              =>
                ( 0
                  1 )
          "reverse" )
        ( ( =>
              =>
                0
            "xs" )
          =>
            ( ( ( 1
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "xs" )
                        "x" ) )
                    =>
                      =>
                        ( 1
                          0 ) ) )
                [] )
              0 ) ) )
      =>
        ( ( ( =>
                =>
                  =>
                    ( 0
                      1 )
              "apply" )
            ( ( =>
                  =>
                    0
                ( ( []
                    "f" )
                  "xs" ) )
              =>
                =>
                  ( ( ( 3
                        ( ( =>
                              =>
                                0
                            ( ( []
                                "f" )
                              "x" ) )
                          =>
                            =>
                              ( 1
                                0 ) ) )
                      1 )
                    ( 2
                      0 ) ) ) )
          =>
            ( ( 0
                ( ( =>
                      =>
                        0
                    ( ( ( []
                          "x" )
                        "y" )
                      "z" ) )
                  =>
                    =>
                      =>
                        ( ( ( Triple
                              2 )
                            1 )
                          0 ) ) )
              ( ( ( []
                    A )
                  B )
                C ) ) ) ) )

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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00005)
00044: LoadVar(00004)
00045: AppFnToArg
00046: LoadVar(00004)
00047: LoadVar(00003)
00048: AppFnToArg
00049: LoadVar(00000)
00050: AppFnToArg
00051: AppFnToArg
00052: LoadVar(00001)
00053: AppFnToArg
00054:   Return
00055: LoadFn { code: 00043, fvars: 00005 }
00056:   Return
00057: LoadVar(00002)
00058:   Return
00059: LoadFn { code: 00037, fvars: 00000 }
00060: LoadVar(00000)
00061: AppFnToArg
00062: LoadFn { code: 00041, fvars: 00000 }
00063: PushString("")
00064: PushString(""xs"")
00065: AppFnToArg
00066: PushString(""x"")
00067: AppFnToArg
00068: AppFnToArg
00069: LoadFn { code: 00055, fvars: 00004 }
00070: AppFnToArg
00071: AppFnToArg
00072: LoadFn { code: 00057, fvars: 00002 }
00073: AppFnToArg
00074:   Return
00075: LoadFn { code: 00059, fvars: 00003 }
00076:   Return
00077: LoadFn { code: 00075, fvars: 00002 }
00078:   Return
00079: LoadFn { code: 00026, fvars: 00000 }
00080: PushString("")
00081: PushString(""f"")
00082: AppFnToArg
00083: PushString(""acc"")
00084: AppFnToArg
00085: PushString(""xs"")
00086: AppFnToArg
00087: AppFnToArg
00088: LoadFn { code: 00077, fvars: 00001 }
00089: AppFnToArg
00090:   Return
00091: LoadVar(00000)
00092: LoadVar(00001)
00093: AppFnToArg
00094:   Return
00095: LoadFn { code: 00091, fvars: 00001 }
00096:   Return
00097: LoadFn { code: 00095, fvars: 00000 }
00098:   Return
00099: LoadVar(00000)
00100:   Return
00101: LoadFn { code: 00099, fvars: 00000 }
00102:   Return
00103: LoadVar(00000)
00104:   Return
00105: LoadFn { code: 00103, fvars: 00000 }
00106:   Return
00107: LoadVar(00001)
00108: LoadVar(00000)
00109: AppFnToArg
00110:   Return
00111: LoadFn { code: 00107, fvars: 00001 }
00112:   Return
00113: LoadVar(00001)
00114: LoadFn { code: 00105, fvars: 00000 }
00115: PushString("")
00116: PushString(""xs"")
00117: AppFnToArg
00118: PushString(""x"")
00119: AppFnToArg
00120: AppFnToArg
00121: LoadFn { code: 00111, fvars: 00000 }
00122: AppFnToArg
00123: AppFnToArg
00124: PushString("")
00125: AppFnToArg
00126: LoadVar(00000)
00127: AppFnToArg
00128:   Return
00129: LoadVar(00000)
00130: LoadVar(00001)
00131: AppFnToArg
00132:   Return
00133: LoadFn { code: 00129, fvars: 00001 }
00134:   Return
00135: LoadFn { code: 00133, fvars: 00000 }
00136:   Return
00137: LoadVar(00000)
00138:   Return
00139: LoadFn { code: 00137, fvars: 00000 }
00140:   Return
00141: LoadVar(00000)
00142:   Return
00143: LoadFn { code: 00141, fvars: 00000 }
00144:   Return
00145: LoadVar(00001)
00146: LoadVar(00000)
00147: AppFnToArg
00148:   Return
00149: LoadFn { code: 00145, fvars: 00001 }
00150:   Return
00151: LoadVar(00003)
00152: LoadFn { code: 00143, fvars: 00000 }
00153: PushString("")
00154: PushString(""f"")
00155: AppFnToArg
00156: PushString(""x"")
00157: AppFnToArg
00158: AppFnToArg
00159: LoadFn { code: 00149, fvars: 00000 }
00160: AppFnToArg
00161: AppFnToArg
00162: LoadVar(00001)
00163: AppFnToArg
00164: LoadVar(00002)
00165: LoadVar(00000)
00166: AppFnToArg
00167: AppFnToArg
00168:   Return
00169: LoadFn { code: 00151, fvars: 00003 }
00170:   Return
00171: LoadVar(00000)
00172:   Return
00173: LoadFn { code: 00171, fvars: 00000 }
00174:   Return
00175: PushString("Triple")
00176: LoadVar(00002)
00177: AppFnToArg
00178: LoadVar(00001)
00179: AppFnToArg
00180: LoadVar(00000)
00181: AppFnToArg
00182:   Return
00183: LoadFn { code: 00175, fvars: 00002 }
00184:   Return
00185: LoadFn { code: 00183, fvars: 00001 }
00186:   Return
00187: LoadVar(00000)
00188: LoadFn { code: 00173, fvars: 00000 }
00189: PushString("")
00190: PushString(""x"")
00191: AppFnToArg
00192: PushString(""y"")
00193: AppFnToArg
00194: PushString(""z"")
00195: AppFnToArg
00196: AppFnToArg
00197: LoadFn { code: 00185, fvars: 00000 }
00198: AppFnToArg
00199: AppFnToArg
00200: PushString("")
00201: PushString("A")
00202: AppFnToArg
00203: PushString("B")
00204: AppFnToArg
00205: PushString("C")
00206: AppFnToArg
00207: AppFnToArg
00208:   Return
00209: LoadFn { code: 00135, fvars: 00000 }
00210: PushString(""apply"")
00211: AppFnToArg
00212: LoadFn { code: 00139, fvars: 00000 }
00213: PushString("")
00214: PushString(""f"")
00215: AppFnToArg
00216: PushString(""xs"")
00217: AppFnToArg
00218: AppFnToArg
00219: LoadFn { code: 00169, fvars: 00002 }
00220: AppFnToArg
00221: AppFnToArg
00222: LoadFn { code: 00187, fvars: 00000 }
00223: AppFnToArg
00224:   Return
00225: LoadFn { code: 00097, fvars: 00000 }
00226: PushString(""reverse"")
00227: AppFnToArg
00228: LoadFn { code: 00101, fvars: 00000 }
00229: PushString(""xs"")
00230: AppFnToArg
00231: LoadFn { code: 00113, fvars: 00001 }
00232: AppFnToArg
00233: AppFnToArg
00234: LoadFn { code: 00209, fvars: 00001 }
00235: AppFnToArg
00236:   Return
00237: LoadFn { code: 00016, fvars: 00000 }
00238: PushString(""fold"")
00239: AppFnToArg
00240: LoadFn { code: 00022, fvars: 00000 }
00241: PushString(""fold"")
00242: AppFnToArg
00243: LoadFn { code: 00079, fvars: 00000 }
00244: AppFnToArg
00245: AppFnToArg
00246: LoadFn { code: 00225, fvars: 00000 }
00247: AppFnToArg
00248:   Return

Triple(A, B, C)

---

:fold = (:fold ~> { [:f, :acc, :xs] => {
    __unpack(xs, [:xs, :x] => {
        fold(f, f(acc, x), xs)
    }, {
        acc
    })
}})
:reverse = (:xs => {
    fold([:xs, :x] => { xs(x) }, [], xs)
})
:map = ([:f, :xs] => {
    fold([:xs, :x] => { xs(f(x)) }, [], reverse(xs))
})
map(:x => { Foo(x) }, [A, B, C])

(=
  :fold
  (~>
    :fold
    { (=>
        ([]
          :f
          :acc
          :xs)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (fold
                  f
                  (f
                    acc
                    x)
                  xs) })
            { acc }) }) }))
(=
  :reverse
  (=>
    :xs
    { (fold
        (=>
          ([]
            :xs
            :x)
          { (xs
              x) })
        []
        xs) }))
(=
  :map
  (=>
    ([]
      :f
      :xs)
    { (fold
        (=>
          ([]
            :xs
            :x)
          { (xs
              (f
                x)) })
        []
        (reverse
          xs)) }))
(map
  (=>
    :x
    { (Foo
        x) })
  ([]
    A
    B
    C))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "fold" )
    ( ( =>
          =>
            ~>
              0
        "fold" )
      =>
        ( ( =>
              =>
                0
            ( ( ( []
                  "f" )
                "acc" )
              "xs" ) )
          =>
            =>
              =>
                ( ( ( =>
                        =>
                          =>
                            ( pop
                              2
                              1
                              0 )
                      0 )
                    ( ( =>
                          =>
                            0
                        ( ( []
                            "xs" )
                          "x" ) )
                      =>
                        =>
                          ( ( ( 5
                                4 )
                              ( ( 4
                                  3 )
                                0 ) )
                            1 ) ) )
                  =>
                    2 ) ) ) )
  =>
    ( ( ( =>
            =>
              =>
                ( 0
                  1 )
          "reverse" )
        ( ( =>
              =>
                0
            "xs" )
          =>
            ( ( ( 1
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "xs" )
                        "x" ) )
                    =>
                      =>
                        ( 1
                          0 ) ) )
                [] )
              0 ) ) )
      =>
        ( ( ( =>
                =>
                  =>
                    ( 0
                      1 )
              "map" )
            ( ( =>
                  =>
                    0
                ( ( []
                    "f" )
                  "xs" ) )
              =>
                =>
                  ( ( ( 3
                        ( ( =>
                              =>
                                0
                            ( ( []
                                "xs" )
                              "x" ) )
                          =>
                            =>
                              ( 1
                                ( 3
                                  0 ) ) ) )
                      [] )
                    ( 2
                      0 ) ) ) )
          =>
            ( ( 0
                ( ( =>
                      =>
                        0
                    "x" )
                  =>
                    ( Foo
                      0 ) ) )
              ( ( ( []
                    A )
                  B )
                C ) ) ) ) )

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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00005)
00044: LoadVar(00004)
00045: AppFnToArg
00046: LoadVar(00004)
00047: LoadVar(00003)
00048: AppFnToArg
00049: LoadVar(00000)
00050: AppFnToArg
00051: AppFnToArg
00052: LoadVar(00001)
00053: AppFnToArg
00054:   Return
00055: LoadFn { code: 00043, fvars: 00005 }
00056:   Return
00057: LoadVar(00002)
00058:   Return
00059: LoadFn { code: 00037, fvars: 00000 }
00060: LoadVar(00000)
00061: AppFnToArg
00062: LoadFn { code: 00041, fvars: 00000 }
00063: PushString("")
00064: PushString(""xs"")
00065: AppFnToArg
00066: PushString(""x"")
00067: AppFnToArg
00068: AppFnToArg
00069: LoadFn { code: 00055, fvars: 00004 }
00070: AppFnToArg
00071: AppFnToArg
00072: LoadFn { code: 00057, fvars: 00002 }
00073: AppFnToArg
00074:   Return
00075: LoadFn { code: 00059, fvars: 00003 }
00076:   Return
00077: LoadFn { code: 00075, fvars: 00002 }
00078:   Return
00079: LoadFn { code: 00026, fvars: 00000 }
00080: PushString("")
00081: PushString(""f"")
00082: AppFnToArg
00083: PushString(""acc"")
00084: AppFnToArg
00085: PushString(""xs"")
00086: AppFnToArg
00087: AppFnToArg
00088: LoadFn { code: 00077, fvars: 00001 }
00089: AppFnToArg
00090:   Return
00091: LoadVar(00000)
00092: LoadVar(00001)
00093: AppFnToArg
00094:   Return
00095: LoadFn { code: 00091, fvars: 00001 }
00096:   Return
00097: LoadFn { code: 00095, fvars: 00000 }
00098:   Return
00099: LoadVar(00000)
00100:   Return
00101: LoadFn { code: 00099, fvars: 00000 }
00102:   Return
00103: LoadVar(00000)
00104:   Return
00105: LoadFn { code: 00103, fvars: 00000 }
00106:   Return
00107: LoadVar(00001)
00108: LoadVar(00000)
00109: AppFnToArg
00110:   Return
00111: LoadFn { code: 00107, fvars: 00001 }
00112:   Return
00113: LoadVar(00001)
00114: LoadFn { code: 00105, fvars: 00000 }
00115: PushString("")
00116: PushString(""xs"")
00117: AppFnToArg
00118: PushString(""x"")
00119: AppFnToArg
00120: AppFnToArg
00121: LoadFn { code: 00111, fvars: 00000 }
00122: AppFnToArg
00123: AppFnToArg
00124: PushString("")
00125: AppFnToArg
00126: LoadVar(00000)
00127: AppFnToArg
00128:   Return
00129: LoadVar(00000)
00130: LoadVar(00001)
00131: AppFnToArg
00132:   Return
00133: LoadFn { code: 00129, fvars: 00001 }
00134:   Return
00135: LoadFn { code: 00133, fvars: 00000 }
00136:   Return
00137: LoadVar(00000)
00138:   Return
00139: LoadFn { code: 00137, fvars: 00000 }
00140:   Return
00141: LoadVar(00000)
00142:   Return
00143: LoadFn { code: 00141, fvars: 00000 }
00144:   Return
00145: LoadVar(00001)
00146: LoadVar(00003)
00147: LoadVar(00000)
00148: AppFnToArg
00149: AppFnToArg
00150:   Return
00151: LoadFn { code: 00145, fvars: 00003 }
00152:   Return
00153: LoadVar(00003)
00154: LoadFn { code: 00143, fvars: 00000 }
00155: PushString("")
00156: PushString(""xs"")
00157: AppFnToArg
00158: PushString(""x"")
00159: AppFnToArg
00160: AppFnToArg
00161: LoadFn { code: 00151, fvars: 00002 }
00162: AppFnToArg
00163: AppFnToArg
00164: PushString("")
00165: AppFnToArg
00166: LoadVar(00002)
00167: LoadVar(00000)
00168: AppFnToArg
00169: AppFnToArg
00170:   Return
00171: LoadFn { code: 00153, fvars: 00003 }
00172:   Return
00173: LoadVar(00000)
00174:   Return
00175: LoadFn { code: 00173, fvars: 00000 }
00176:   Return
00177: PushString("Foo")
00178: LoadVar(00000)
00179: AppFnToArg
00180:   Return
00181: LoadVar(00000)
00182: LoadFn { code: 00175, fvars: 00000 }
00183: PushString(""x"")
00184: AppFnToArg
00185: LoadFn { code: 00177, fvars: 00000 }
00186: AppFnToArg
00187: AppFnToArg
00188: PushString("")
00189: PushString("A")
00190: AppFnToArg
00191: PushString("B")
00192: AppFnToArg
00193: PushString("C")
00194: AppFnToArg
00195: AppFnToArg
00196:   Return
00197: LoadFn { code: 00135, fvars: 00000 }
00198: PushString(""map"")
00199: AppFnToArg
00200: LoadFn { code: 00139, fvars: 00000 }
00201: PushString("")
00202: PushString(""f"")
00203: AppFnToArg
00204: PushString(""xs"")
00205: AppFnToArg
00206: AppFnToArg
00207: LoadFn { code: 00171, fvars: 00002 }
00208: AppFnToArg
00209: AppFnToArg
00210: LoadFn { code: 00181, fvars: 00000 }
00211: AppFnToArg
00212:   Return
00213: LoadFn { code: 00097, fvars: 00000 }
00214: PushString(""reverse"")
00215: AppFnToArg
00216: LoadFn { code: 00101, fvars: 00000 }
00217: PushString(""xs"")
00218: AppFnToArg
00219: LoadFn { code: 00113, fvars: 00001 }
00220: AppFnToArg
00221: AppFnToArg
00222: LoadFn { code: 00197, fvars: 00001 }
00223: AppFnToArg
00224:   Return
00225: LoadFn { code: 00016, fvars: 00000 }
00226: PushString(""fold"")
00227: AppFnToArg
00228: LoadFn { code: 00022, fvars: 00000 }
00229: PushString(""fold"")
00230: AppFnToArg
00231: LoadFn { code: 00079, fvars: 00000 }
00232: AppFnToArg
00233: AppFnToArg
00234: LoadFn { code: 00213, fvars: 00000 }
00235: AppFnToArg
00236:   Return

[Foo(A), Foo(B), Foo(C)]

---

:fold = (:fold ~> { [:f, :acc, :xs] => {
    __unpack(xs, [:xs, :x] => {
        fold(f, f(acc, x), xs)
    }, {
        acc
    })
}})
:reverse = (:xs => {
    fold([:xs, :x] => { xs(x) }, [], xs)
})
:zip = (:zip ~> { [:acc, :xs, :ys] => {
    __unpack(xs, [:xs, :x] => {
        __unpack(ys, [:ys, :y] => { zip(acc([x, y]), xs, ys) }, {})
    }, {
        __unpack(ys, [:ys, :y] => {}, { acc })
    })
}})
:zip = ([:xs, :ys] => { reverse(zip([], xs, ys)) })
[
    zip([A, B, C], [X, Y, Z])
    zip([A, B, C], [X, Y])
    zip([A, B], [X, Y, Z])
    zip(Foo, [X, Y, Z])
    zip(Foo, Bar)
]

(=
  :fold
  (~>
    :fold
    { (=>
        ([]
          :f
          :acc
          :xs)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (fold
                  f
                  (f
                    acc
                    x)
                  xs) })
            { acc }) }) }))
(=
  :reverse
  (=>
    :xs
    { (fold
        (=>
          ([]
            :xs
            :x)
          { (xs
              x) })
        []
        xs) }))
(=
  :zip
  (~>
    :zip
    { (=>
        ([]
          :acc
          :xs
          :ys)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (__unpack
                  ys
                  (=>
                    ([]
                      :ys
                      :y)
                    { (zip
                        (acc
                          ([]
                            x
                            y))
                        xs
                        ys) })
                  {  }) })
            { (__unpack
                ys
                (=>
                  ([]
                    :ys
                    :y)
                  {  })
                { acc }) }) }) }))
(=
  :zip
  (=>
    ([]
      :xs
      :ys)
    { (reverse
        (zip
          []
          xs
          ys)) }))
([]
  (zip
    ([]
      A
      B
      C)
    ([]
      X
      Y
      Z))
  (zip
    ([]
      A
      B
      C)
    ([]
      X
      Y))
  (zip
    ([]
      A
      B)
    ([]
      X
      Y
      Z))
  (zip
    Foo
    ([]
      X
      Y
      Z))
  (zip
    Foo
    Bar))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "fold" )
    ( ( =>
          =>
            ~>
              0
        "fold" )
      =>
        ( ( =>
              =>
                0
            ( ( ( []
                  "f" )
                "acc" )
              "xs" ) )
          =>
            =>
              =>
                ( ( ( =>
                        =>
                          =>
                            ( pop
                              2
                              1
                              0 )
                      0 )
                    ( ( =>
                          =>
                            0
                        ( ( []
                            "xs" )
                          "x" ) )
                      =>
                        =>
                          ( ( ( 5
                                4 )
                              ( ( 4
                                  3 )
                                0 ) )
                            1 ) ) )
                  =>
                    2 ) ) ) )
  =>
    ( ( ( =>
            =>
              =>
                ( 0
                  1 )
          "reverse" )
        ( ( =>
              =>
                0
            "xs" )
          =>
            ( ( ( 1
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "xs" )
                        "x" ) )
                    =>
                      =>
                        ( 1
                          0 ) ) )
                [] )
              0 ) ) )
      =>
        ( ( ( =>
                =>
                  =>
                    ( 0
                      1 )
              "zip" )
            ( ( =>
                  =>
                    ~>
                      0
                "zip" )
              =>
                ( ( =>
                      =>
                        0
                    ( ( ( []
                          "acc" )
                        "xs" )
                      "ys" ) )
                  =>
                    =>
                      =>
                        ( ( ( =>
                                =>
                                  =>
                                    ( pop
                                      2
                                      1
                                      0 )
                              1 )
                            ( ( =>
                                  =>
                                    0
                                ( ( []
                                    "xs" )
                                  "x" ) )
                              =>
                                =>
                                  ( ( ( =>
                                          =>
                                            =>
                                              ( pop
                                                2
                                                1
                                                0 )
                                        2 )
                                      ( ( =>
                                            =>
                                              0
                                          ( ( []
                                              "ys" )
                                            "y" ) )
                                        =>
                                          =>
                                            ( ( ( 7
                                                  ( 6
                                                    ( ( []
                                                        2 )
                                                      0 ) ) )
                                                3 )
                                              1 ) ) )
                                    =>
                                      [] ) ) )
                          =>
                            ( ( ( =>
                                    =>
                                      =>
                                        ( pop
                                          2
                                          1
                                          0 )
                                  1 )
                                ( ( =>
                                      =>
                                        0
                                    ( ( []
                                        "ys" )
                                      "y" ) )
                                  =>
                                    =>
                                      [] ) )
                              =>
                                4 ) ) ) ) )
          =>
            ( ( ( =>
                    =>
                      =>
                        ( 0
                          1 )
                  "zip" )
                ( ( =>
                      =>
                        0
                    ( ( []
                        "xs" )
                      "ys" ) )
                  =>
                    =>
                      ( 3
                        ( ( ( 2
                              [] )
                            1 )
                          0 ) ) ) )
              =>
                ( ( ( ( ( []
                          ( ( 0
                              ( ( ( []
                                    A )
                                  B )
                                C ) )
                            ( ( ( []
                                  X )
                                Y )
                              Z ) ) )
                        ( ( 0
                            ( ( ( []
                                  A )
                                B )
                              C ) )
                          ( ( []
                              X )
                            Y ) ) )
                      ( ( 0
                          ( ( []
                              A )
                            B ) )
                        ( ( ( []
                              X )
                            Y )
                          Z ) ) )
                    ( ( 0
                        Foo )
                      ( ( ( []
                            X )
                          Y )
                        Z ) ) )
                  ( ( 0
                      Foo )
                    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(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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00005)
00044: LoadVar(00004)
00045: AppFnToArg
00046: LoadVar(00004)
00047: LoadVar(00003)
00048: AppFnToArg
00049: LoadVar(00000)
00050: AppFnToArg
00051: AppFnToArg
00052: LoadVar(00001)
00053: AppFnToArg
00054:   Return
00055: LoadFn { code: 00043, fvars: 00005 }
00056:   Return
00057: LoadVar(00002)
00058:   Return
00059: LoadFn { code: 00037, fvars: 00000 }
00060: LoadVar(00000)
00061: AppFnToArg
00062: LoadFn { code: 00041, fvars: 00000 }
00063: PushString("")
00064: PushString(""xs"")
00065: AppFnToArg
00066: PushString(""x"")
00067: AppFnToArg
00068: AppFnToArg
00069: LoadFn { code: 00055, fvars: 00004 }
00070: AppFnToArg
00071: AppFnToArg
00072: LoadFn { code: 00057, fvars: 00002 }
00073: AppFnToArg
00074:   Return
00075: LoadFn { code: 00059, fvars: 00003 }
00076:   Return
00077: LoadFn { code: 00075, fvars: 00002 }
00078:   Return
00079: LoadFn { code: 00026, fvars: 00000 }
00080: PushString("")
00081: PushString(""f"")
00082: AppFnToArg
00083: PushString(""acc"")
00084: AppFnToArg
00085: PushString(""xs"")
00086: AppFnToArg
00087: AppFnToArg
00088: LoadFn { code: 00077, fvars: 00001 }
00089: AppFnToArg
00090:   Return
00091: LoadVar(00000)
00092: LoadVar(00001)
00093: AppFnToArg
00094:   Return
00095: LoadFn { code: 00091, fvars: 00001 }
00096:   Return
00097: LoadFn { code: 00095, fvars: 00000 }
00098:   Return
00099: LoadVar(00000)
00100:   Return
00101: LoadFn { code: 00099, fvars: 00000 }
00102:   Return
00103: LoadVar(00000)
00104:   Return
00105: LoadFn { code: 00103, fvars: 00000 }
00106:   Return
00107: LoadVar(00001)
00108: LoadVar(00000)
00109: AppFnToArg
00110:   Return
00111: LoadFn { code: 00107, fvars: 00001 }
00112:   Return
00113: LoadVar(00001)
00114: LoadFn { code: 00105, fvars: 00000 }
00115: PushString("")
00116: PushString(""xs"")
00117: AppFnToArg
00118: PushString(""x"")
00119: AppFnToArg
00120: AppFnToArg
00121: LoadFn { code: 00111, fvars: 00000 }
00122: AppFnToArg
00123: AppFnToArg
00124: PushString("")
00125: AppFnToArg
00126: LoadVar(00000)
00127: AppFnToArg
00128:   Return
00129: LoadVar(00000)
00130: LoadVar(00001)
00131: AppFnToArg
00132:   Return
00133: LoadFn { code: 00129, fvars: 00001 }
00134:   Return
00135: LoadFn { code: 00133, fvars: 00000 }
00136:   Return
00137: LoadVar(00000)
00138: LoadFn { code: 00000, fvars: 00000 }
00139: AppArgToFn
00140:   Return
00141: LoadFn { code: 00137, fvars: 00000 }
00142:   Return
00143: LoadVar(00000)
00144:   Return
00145: LoadFn { code: 00143, fvars: 00000 }
00146:   Return
00147: LoadVar(00002)
00148: LoadVar(00001)
00149: LoadVar(00000)
00150: Unpack
00151: AppArgToFn
00152: AppArgToFn
00153:   Return
00154: LoadFn { code: 00147, fvars: 00002 }
00155:   Return
00156: LoadFn { code: 00154, fvars: 00001 }
00157:   Return
00158: LoadVar(00000)
00159:   Return
00160: LoadFn { code: 00158, fvars: 00000 }
00161:   Return
00162: LoadVar(00002)
00163: LoadVar(00001)
00164: LoadVar(00000)
00165: Unpack
00166: AppArgToFn
00167: AppArgToFn
00168:   Return
00169: LoadFn { code: 00162, fvars: 00002 }
00170:   Return
00171: LoadFn { code: 00169, fvars: 00001 }
00172:   Return
00173: LoadVar(00000)
00174:   Return
00175: LoadFn { code: 00173, fvars: 00000 }
00176:   Return
00177: LoadVar(00007)
00178: LoadVar(00006)
00179: PushString("")
00180: LoadVar(00002)
00181: AppFnToArg
00182: LoadVar(00000)
00183: AppFnToArg
00184: AppFnToArg
00185: AppFnToArg
00186: LoadVar(00003)
00187: AppFnToArg
00188: LoadVar(00001)
00189: AppFnToArg
00190:   Return
00191: LoadFn { code: 00177, fvars: 00007 }
00192:   Return
00193: PushString("")
00194:   Return
00195: LoadFn { code: 00171, fvars: 00000 }
00196: LoadVar(00002)
00197: AppFnToArg
00198: LoadFn { code: 00175, fvars: 00000 }
00199: PushString("")
00200: PushString(""ys"")
00201: AppFnToArg
00202: PushString(""y"")
00203: AppFnToArg
00204: AppFnToArg
00205: LoadFn { code: 00191, fvars: 00006 }
00206: AppFnToArg
00207: AppFnToArg
00208: LoadFn { code: 00193, fvars: 00000 }
00209: AppFnToArg
00210:   Return
00211: LoadFn { code: 00195, fvars: 00005 }
00212:   Return
00213: LoadVar(00002)
00214: LoadVar(00001)
00215: LoadVar(00000)
00216: Unpack
00217: AppArgToFn
00218: AppArgToFn
00219:   Return
00220: LoadFn { code: 00213, fvars: 00002 }
00221:   Return
00222: LoadFn { code: 00220, fvars: 00001 }
00223:   Return
00224: LoadVar(00000)
00225:   Return
00226: LoadFn { code: 00224, fvars: 00000 }
00227:   Return
00228: PushString("")
00229:   Return
00230: LoadFn { code: 00228, fvars: 00000 }
00231:   Return
00232: LoadVar(00004)
00233:   Return
00234: LoadFn { code: 00222, fvars: 00000 }
00235: LoadVar(00001)
00236: AppFnToArg
00237: LoadFn { code: 00226, fvars: 00000 }
00238: PushString("")
00239: PushString(""ys"")
00240: AppFnToArg
00241: PushString(""y"")
00242: AppFnToArg
00243: AppFnToArg
00244: LoadFn { code: 00230, fvars: 00000 }
00245: AppFnToArg
00246: AppFnToArg
00247: LoadFn { code: 00232, fvars: 00004 }
00248: AppFnToArg
00249:   Return
00250: LoadFn { code: 00156, fvars: 00000 }
00251: LoadVar(00001)
00252: AppFnToArg
00253: LoadFn { code: 00160, fvars: 00000 }
00254: PushString("")
00255: PushString(""xs"")
00256: AppFnToArg
00257: PushString(""x"")
00258: AppFnToArg
00259: AppFnToArg
00260: LoadFn { code: 00211, fvars: 00004 }
00261: AppFnToArg
00262: AppFnToArg
00263: LoadFn { code: 00234, fvars: 00003 }
00264: AppFnToArg
00265:   Return
00266: LoadFn { code: 00250, fvars: 00003 }
00267:   Return
00268: LoadFn { code: 00266, fvars: 00002 }
00269:   Return
00270: LoadFn { code: 00145, fvars: 00000 }
00271: PushString("")
00272: PushString(""acc"")
00273: AppFnToArg
00274: PushString(""xs"")
00275: AppFnToArg
00276: PushString(""ys"")
00277: AppFnToArg
00278: AppFnToArg
00279: LoadFn { code: 00268, fvars: 00001 }
00280: AppFnToArg
00281:   Return
00282: LoadVar(00000)
00283: LoadVar(00001)
00284: AppFnToArg
00285:   Return
00286: LoadFn { code: 00282, fvars: 00001 }
00287:   Return
00288: LoadFn { code: 00286, fvars: 00000 }
00289:   Return
00290: LoadVar(00000)
00291:   Return
00292: LoadFn { code: 00290, fvars: 00000 }
00293:   Return
00294: LoadVar(00003)
00295: LoadVar(00002)
00296: PushString("")
00297: AppFnToArg
00298: LoadVar(00001)
00299: AppFnToArg
00300: LoadVar(00000)
00301: AppFnToArg
00302: AppFnToArg
00303:   Return
00304: LoadFn { code: 00294, fvars: 00003 }
00305:   Return
00306: PushString("")
00307: LoadVar(00000)
00308: PushString("")
00309: PushString("A")
00310: AppFnToArg
00311: PushString("B")
00312: AppFnToArg
00313: PushString("C")
00314: AppFnToArg
00315: AppFnToArg
00316: PushString("")
00317: PushString("X")
00318: AppFnToArg
00319: PushString("Y")
00320: AppFnToArg
00321: PushString("Z")
00322: AppFnToArg
00323: AppFnToArg
00324: AppFnToArg
00325: LoadVar(00000)
00326: PushString("")
00327: PushString("A")
00328: AppFnToArg
00329: PushString("B")
00330: AppFnToArg
00331: PushString("C")
00332: AppFnToArg
00333: AppFnToArg
00334: PushString("")
00335: PushString("X")
00336: AppFnToArg
00337: PushString("Y")
00338: AppFnToArg
00339: AppFnToArg
00340: AppFnToArg
00341: LoadVar(00000)
00342: PushString("")
00343: PushString("A")
00344: AppFnToArg
00345: PushString("B")
00346: AppFnToArg
00347: AppFnToArg
00348: PushString("")
00349: PushString("X")
00350: AppFnToArg
00351: PushString("Y")
00352: AppFnToArg
00353: PushString("Z")
00354: AppFnToArg
00355: AppFnToArg
00356: AppFnToArg
00357: LoadVar(00000)
00358: PushString("Foo")
00359: AppFnToArg
00360: PushString("")
00361: PushString("X")
00362: AppFnToArg
00363: PushString("Y")
00364: AppFnToArg
00365: PushString("Z")
00366: AppFnToArg
00367: AppFnToArg
00368: AppFnToArg
00369: LoadVar(00000)
00370: PushString("Foo")
00371: AppFnToArg
00372: PushString("Bar")
00373: AppFnToArg
00374: AppFnToArg
00375:   Return
00376: LoadFn { code: 00288, fvars: 00000 }
00377: PushString(""zip"")
00378: AppFnToArg
00379: LoadFn { code: 00292, fvars: 00000 }
00380: PushString("")
00381: PushString(""xs"")
00382: AppFnToArg
00383: PushString(""ys"")
00384: AppFnToArg
00385: AppFnToArg
00386: LoadFn { code: 00304, fvars: 00002 }
00387: AppFnToArg
00388: AppFnToArg
00389: LoadFn { code: 00306, fvars: 00000 }
00390: AppFnToArg
00391:   Return
00392: LoadFn { code: 00135, fvars: 00000 }
00393: PushString(""zip"")
00394: AppFnToArg
00395: LoadFn { code: 00141, fvars: 00000 }
00396: PushString(""zip"")
00397: AppFnToArg
00398: LoadFn { code: 00270, fvars: 00000 }
00399: AppFnToArg
00400: AppFnToArg
00401: LoadFn { code: 00376, fvars: 00001 }
00402: AppFnToArg
00403:   Return
00404: LoadFn { code: 00097, fvars: 00000 }
00405: PushString(""reverse"")
00406: AppFnToArg
00407: LoadFn { code: 00101, fvars: 00000 }
00408: PushString(""xs"")
00409: AppFnToArg
00410: LoadFn { code: 00113, fvars: 00001 }
00411: AppFnToArg
00412: AppFnToArg
00413: LoadFn { code: 00392, fvars: 00000 }
00414: AppFnToArg
00415:   Return
00416: LoadFn { code: 00016, fvars: 00000 }
00417: PushString(""fold"")
00418: AppFnToArg
00419: LoadFn { code: 00022, fvars: 00000 }
00420: PushString(""fold"")
00421: AppFnToArg
00422: LoadFn { code: 00079, fvars: 00000 }
00423: AppFnToArg
00424: AppFnToArg
00425: LoadFn { code: 00404, fvars: 00000 }
00426: AppFnToArg
00427:   Return

[[[A, X], [B, Y], [C, Z]], [], [], [], []]

---

:== = (:== ~> { [:a, :b] => {
    __unpack(a, [:xs, :x] => {
        __unpack(b, [:ys, :y] => {
            __compare(x == y, True, { xs == ys }, { False })
        }, {
            False
        })
    }, {
        __compare(a, b, { True }, { False })
    })
}})
[
    Foo == Foo
    Foo == Bar
    Foo(Bar) == Foo(Bar)
    Foo(Bar) == Foo(Baz)
    :a == :a
    :a == :b
    :f(:a) == :f(:a)
    :f(:a) == :g(:a)
]

(=
  :==
  (~>
    :==
    { (=>
        ([]
          :a
          :b)
        { (__unpack
            a
            (=>
              ([]
                :xs
                :x)
              { (__unpack
                  b
                  (=>
                    ([]
                      :ys
                      :y)
                    { (__compare
                        (==
                          x
                          y)
                        True
                        { (==
                            xs
                            ys) }
                        { False }) })
                  { False }) })
            { (__compare
                a
                b
                { True }
                { False }) }) }) }))
([]
  (==
    Foo
    Foo)
  (==
    Foo
    Bar)
  (==
    (Foo
      Bar)
    (Foo
      Bar))
  (==
    (Foo
      Bar)
    (Foo
      Baz))
  (==
    :a
    :a)
  (==
    :a
    :b)
  (==
    (:f
      :a)
    (:f
      :a))
  (==
    (:f
      :a)
    (:g
      :a)))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "==" )
    ( ( =>
          =>
            ~>
              0
        "==" )
      =>
        ( ( =>
              =>
                0
            ( ( []
                "a" )
              "b" ) )
          =>
            =>
              ( ( ( =>
                      =>
                        =>
                          ( pop
                            2
                            1
                            0 )
                    1 )
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "xs" )
                        "x" ) )
                    =>
                      =>
                        ( ( ( =>
                                =>
                                  =>
                                    ( pop
                                      2
                                      1
                                      0 )
                              2 )
                            ( ( =>
                                  =>
                                    0
                                ( ( []
                                    "ys" )
                                  "y" ) )
                              =>
                                =>
                                  ( ( ( ( =>
                                            =>
                                              =>
                                                =>
                                                  ( if
                                                    3
                                                    2
                                                    1
                                                    0 )
                                          ( ( 6
                                              2 )
                                            0 ) )
                                        True )
                                      =>
                                        ( ( 7
                                            4 )
                                          2 ) )
                                    =>
                                      False ) ) )
                          =>
                            False ) ) )
                =>
                  ( ( ( ( =>
                            =>
                              =>
                                =>
                                  ( if
                                    3
                                    2
                                    1
                                    0 )
                          2 )
                        1 )
                      =>
                        True )
                    =>
                      False ) ) ) ) )
  =>
    ( ( ( ( ( ( ( ( []
                    ( ( 0
                        Foo )
                      Foo ) )
                  ( ( 0
                      Foo )
                    Bar ) )
                ( ( 0
                    ( Foo
                      Bar ) )
                  ( Foo
                    Bar ) ) )
              ( ( 0
                  ( Foo
                    Bar ) )
                ( Foo
                  Baz ) ) )
            ( ( 0
                "a" )
              "a" ) )
          ( ( 0
              "a" )
            "b" ) )
        ( ( 0
            ( "f"
              "a" ) )
          ( "f"
            "a" ) ) )
      ( ( 0
          ( "f"
            "a" ) )
        ( "g"
          "a" ) ) ) )

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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00002)
00044: LoadVar(00001)
00045: LoadVar(00000)
00046: Unpack
00047: AppArgToFn
00048: AppArgToFn
00049:   Return
00050: LoadFn { code: 00043, fvars: 00002 }
00051:   Return
00052: LoadFn { code: 00050, fvars: 00001 }
00053:   Return
00054: LoadVar(00000)
00055:   Return
00056: LoadFn { code: 00054, fvars: 00000 }
00057:   Return
00058: LoadVar(00003)
00059: LoadVar(00002)
00060: LoadVar(00001)
00061: LoadVar(00000)
00062: Compare
00063: AppArgToFn
00064:   Return
00065: LoadFn { code: 00058, fvars: 00003 }
00066:   Return
00067: LoadFn { code: 00065, fvars: 00002 }
00068:   Return
00069: LoadFn { code: 00067, fvars: 00001 }
00070:   Return
00071: LoadVar(00007)
00072: LoadVar(00004)
00073: AppFnToArg
00074: LoadVar(00002)
00075: AppFnToArg
00076:   Return
00077: PushString("False")
00078:   Return
00079: LoadFn { code: 00069, fvars: 00000 }
00080: LoadVar(00006)
00081: LoadVar(00002)
00082: AppFnToArg
00083: LoadVar(00000)
00084: AppFnToArg
00085: AppFnToArg
00086: PushString("True")
00087: AppFnToArg
00088: LoadFn { code: 00071, fvars: 00007 }
00089: AppFnToArg
00090: LoadFn { code: 00077, fvars: 00000 }
00091: AppFnToArg
00092:   Return
00093: LoadFn { code: 00079, fvars: 00006 }
00094:   Return
00095: PushString("False")
00096:   Return
00097: LoadFn { code: 00052, fvars: 00000 }
00098: LoadVar(00002)
00099: AppFnToArg
00100: LoadFn { code: 00056, fvars: 00000 }
00101: PushString("")
00102: PushString(""ys"")
00103: AppFnToArg
00104: PushString(""y"")
00105: AppFnToArg
00106: AppFnToArg
00107: LoadFn { code: 00093, fvars: 00005 }
00108: AppFnToArg
00109: AppFnToArg
00110: LoadFn { code: 00095, fvars: 00000 }
00111: AppFnToArg
00112:   Return
00113: LoadFn { code: 00097, fvars: 00004 }
00114:   Return
00115: LoadVar(00003)
00116: LoadVar(00002)
00117: LoadVar(00001)
00118: LoadVar(00000)
00119: Compare
00120: AppArgToFn
00121:   Return
00122: LoadFn { code: 00115, fvars: 00003 }
00123:   Return
00124: LoadFn { code: 00122, fvars: 00002 }
00125:   Return
00126: LoadFn { code: 00124, fvars: 00001 }
00127:   Return
00128: PushString("True")
00129:   Return
00130: PushString("False")
00131:   Return
00132: LoadFn { code: 00126, fvars: 00000 }
00133: LoadVar(00002)
00134: AppFnToArg
00135: LoadVar(00001)
00136: AppFnToArg
00137: LoadFn { code: 00128, fvars: 00000 }
00138: AppFnToArg
00139: LoadFn { code: 00130, fvars: 00000 }
00140: AppFnToArg
00141:   Return
00142: LoadFn { code: 00037, fvars: 00000 }
00143: LoadVar(00001)
00144: AppFnToArg
00145: LoadFn { code: 00041, fvars: 00000 }
00146: PushString("")
00147: PushString(""xs"")
00148: AppFnToArg
00149: PushString(""x"")
00150: AppFnToArg
00151: AppFnToArg
00152: LoadFn { code: 00113, fvars: 00003 }
00153: AppFnToArg
00154: AppFnToArg
00155: LoadFn { code: 00132, fvars: 00002 }
00156: AppFnToArg
00157:   Return
00158: LoadFn { code: 00142, fvars: 00002 }
00159:   Return
00160: LoadFn { code: 00026, fvars: 00000 }
00161: PushString("")
00162: PushString(""a"")
00163: AppFnToArg
00164: PushString(""b"")
00165: AppFnToArg
00166: AppFnToArg
00167: LoadFn { code: 00158, fvars: 00001 }
00168: AppFnToArg
00169:   Return
00170: PushString("")
00171: LoadVar(00000)
00172: PushString("Foo")
00173: AppFnToArg
00174: PushString("Foo")
00175: AppFnToArg
00176: AppFnToArg
00177: LoadVar(00000)
00178: PushString("Foo")
00179: AppFnToArg
00180: PushString("Bar")
00181: AppFnToArg
00182: AppFnToArg
00183: LoadVar(00000)
00184: PushString("Foo")
00185: PushString("Bar")
00186: AppFnToArg
00187: AppFnToArg
00188: PushString("Foo")
00189: PushString("Bar")
00190: AppFnToArg
00191: AppFnToArg
00192: AppFnToArg
00193: LoadVar(00000)
00194: PushString("Foo")
00195: PushString("Bar")
00196: AppFnToArg
00197: AppFnToArg
00198: PushString("Foo")
00199: PushString("Baz")
00200: AppFnToArg
00201: AppFnToArg
00202: AppFnToArg
00203: LoadVar(00000)
00204: PushString(""a"")
00205: AppFnToArg
00206: PushString(""a"")
00207: AppFnToArg
00208: AppFnToArg
00209: LoadVar(00000)
00210: PushString(""a"")
00211: AppFnToArg
00212: PushString(""b"")
00213: AppFnToArg
00214: AppFnToArg
00215: LoadVar(00000)
00216: PushString(""f"")
00217: PushString(""a"")
00218: AppFnToArg
00219: AppFnToArg
00220: PushString(""f"")
00221: PushString(""a"")
00222: AppFnToArg
00223: AppFnToArg
00224: AppFnToArg
00225: LoadVar(00000)
00226: PushString(""f"")
00227: PushString(""a"")
00228: AppFnToArg
00229: AppFnToArg
00230: PushString(""g"")
00231: PushString(""a"")
00232: AppFnToArg
00233: AppFnToArg
00234: AppFnToArg
00235:   Return
00236: LoadFn { code: 00016, fvars: 00000 }
00237: PushString(""=="")
00238: AppFnToArg
00239: LoadFn { code: 00022, fvars: 00000 }
00240: PushString(""=="")
00241: AppFnToArg
00242: LoadFn { code: 00160, fvars: 00000 }
00243: AppFnToArg
00244: AppFnToArg
00245: LoadFn { code: 00170, fvars: 00000 }
00246: AppFnToArg
00247:   Return

[True, False, True, False, True, False, True, False]

---

:fold = (:fold ~> { [:f, :acc, :xs] => {
    __unpack(xs, [:xs, :x] => {
        fold(f, f(acc, x), xs)
    }, {
        acc
    })
}})
:reverse = (:xs => {
    fold([:xs, :x] => { xs(x) }, [], xs)
})
:flatten = (:xs => {
    reverse(fold([:acc, :x] => {
        fold([:acc, :x] => { acc(x) }, acc, x)
    }, [], xs))
})
flatten([[A, B], [C, D]])

(=
  :fold
  (~>
    :fold
    { (=>
        ([]
          :f
          :acc
          :xs)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (fold
                  f
                  (f
                    acc
                    x)
                  xs) })
            { acc }) }) }))
(=
  :reverse
  (=>
    :xs
    { (fold
        (=>
          ([]
            :xs
            :x)
          { (xs
              x) })
        []
        xs) }))
(=
  :flatten
  (=>
    :xs
    { (reverse
        (fold
          (=>
            ([]
              :acc
              :x)
            { (fold
                (=>
                  ([]
                    :acc
                    :x)
                  { (acc
                      x) })
                acc
                x) })
          []
          xs)) }))
(flatten
  ([]
    ([]
      A
      B)
    ([]
      C
      D)))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "fold" )
    ( ( =>
          =>
            ~>
              0
        "fold" )
      =>
        ( ( =>
              =>
                0
            ( ( ( []
                  "f" )
                "acc" )
              "xs" ) )
          =>
            =>
              =>
                ( ( ( =>
                        =>
                          =>
                            ( pop
                              2
                              1
                              0 )
                      0 )
                    ( ( =>
                          =>
                            0
                        ( ( []
                            "xs" )
                          "x" ) )
                      =>
                        =>
                          ( ( ( 5
                                4 )
                              ( ( 4
                                  3 )
                                0 ) )
                            1 ) ) )
                  =>
                    2 ) ) ) )
  =>
    ( ( ( =>
            =>
              =>
                ( 0
                  1 )
          "reverse" )
        ( ( =>
              =>
                0
            "xs" )
          =>
            ( ( ( 1
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "xs" )
                        "x" ) )
                    =>
                      =>
                        ( 1
                          0 ) ) )
                [] )
              0 ) ) )
      =>
        ( ( ( =>
                =>
                  =>
                    ( 0
                      1 )
              "flatten" )
            ( ( =>
                  =>
                    0
                "xs" )
              =>
                ( 1
                  ( ( ( 2
                        ( ( =>
                              =>
                                0
                            ( ( []
                                "acc" )
                              "x" ) )
                          =>
                            =>
                              ( ( ( 4
                                    ( ( =>
                                          =>
                                            0
                                        ( ( []
                                            "acc" )
                                          "x" ) )
                                      =>
                                        =>
                                          ( 1
                                            0 ) ) )
                                  1 )
                                0 ) ) )
                      [] )
                    0 ) ) ) )
          =>
            ( 0
              ( ( []
                  ( ( []
                      A )
                    B ) )
                ( ( []
                    C )
                  D ) ) ) ) ) )

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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00005)
00044: LoadVar(00004)
00045: AppFnToArg
00046: LoadVar(00004)
00047: LoadVar(00003)
00048: AppFnToArg
00049: LoadVar(00000)
00050: AppFnToArg
00051: AppFnToArg
00052: LoadVar(00001)
00053: AppFnToArg
00054:   Return
00055: LoadFn { code: 00043, fvars: 00005 }
00056:   Return
00057: LoadVar(00002)
00058:   Return
00059: LoadFn { code: 00037, fvars: 00000 }
00060: LoadVar(00000)
00061: AppFnToArg
00062: LoadFn { code: 00041, fvars: 00000 }
00063: PushString("")
00064: PushString(""xs"")
00065: AppFnToArg
00066: PushString(""x"")
00067: AppFnToArg
00068: AppFnToArg
00069: LoadFn { code: 00055, fvars: 00004 }
00070: AppFnToArg
00071: AppFnToArg
00072: LoadFn { code: 00057, fvars: 00002 }
00073: AppFnToArg
00074:   Return
00075: LoadFn { code: 00059, fvars: 00003 }
00076:   Return
00077: LoadFn { code: 00075, fvars: 00002 }
00078:   Return
00079: LoadFn { code: 00026, fvars: 00000 }
00080: PushString("")
00081: PushString(""f"")
00082: AppFnToArg
00083: PushString(""acc"")
00084: AppFnToArg
00085: PushString(""xs"")
00086: AppFnToArg
00087: AppFnToArg
00088: LoadFn { code: 00077, fvars: 00001 }
00089: AppFnToArg
00090:   Return
00091: LoadVar(00000)
00092: LoadVar(00001)
00093: AppFnToArg
00094:   Return
00095: LoadFn { code: 00091, fvars: 00001 }
00096:   Return
00097: LoadFn { code: 00095, fvars: 00000 }
00098:   Return
00099: LoadVar(00000)
00100:   Return
00101: LoadFn { code: 00099, fvars: 00000 }
00102:   Return
00103: LoadVar(00000)
00104:   Return
00105: LoadFn { code: 00103, fvars: 00000 }
00106:   Return
00107: LoadVar(00001)
00108: LoadVar(00000)
00109: AppFnToArg
00110:   Return
00111: LoadFn { code: 00107, fvars: 00001 }
00112:   Return
00113: LoadVar(00001)
00114: LoadFn { code: 00105, fvars: 00000 }
00115: PushString("")
00116: PushString(""xs"")
00117: AppFnToArg
00118: PushString(""x"")
00119: AppFnToArg
00120: AppFnToArg
00121: LoadFn { code: 00111, fvars: 00000 }
00122: AppFnToArg
00123: AppFnToArg
00124: PushString("")
00125: AppFnToArg
00126: LoadVar(00000)
00127: AppFnToArg
00128:   Return
00129: LoadVar(00000)
00130: LoadVar(00001)
00131: AppFnToArg
00132:   Return
00133: LoadFn { code: 00129, fvars: 00001 }
00134:   Return
00135: LoadFn { code: 00133, fvars: 00000 }
00136:   Return
00137: LoadVar(00000)
00138:   Return
00139: LoadFn { code: 00137, fvars: 00000 }
00140:   Return
00141: LoadVar(00000)
00142:   Return
00143: LoadFn { code: 00141, fvars: 00000 }
00144:   Return
00145: LoadVar(00000)
00146:   Return
00147: LoadFn { code: 00145, fvars: 00000 }
00148:   Return
00149: LoadVar(00001)
00150: LoadVar(00000)
00151: AppFnToArg
00152:   Return
00153: LoadFn { code: 00149, fvars: 00001 }
00154:   Return
00155: LoadVar(00004)
00156: LoadFn { code: 00147, fvars: 00000 }
00157: PushString("")
00158: PushString(""acc"")
00159: AppFnToArg
00160: PushString(""x"")
00161: AppFnToArg
00162: AppFnToArg
00163: LoadFn { code: 00153, fvars: 00000 }
00164: AppFnToArg
00165: AppFnToArg
00166: LoadVar(00001)
00167: AppFnToArg
00168: LoadVar(00000)
00169: AppFnToArg
00170:   Return
00171: LoadFn { code: 00155, fvars: 00004 }
00172:   Return
00173: LoadVar(00001)
00174: LoadVar(00002)
00175: LoadFn { code: 00143, fvars: 00000 }
00176: PushString("")
00177: PushString(""acc"")
00178: AppFnToArg
00179: PushString(""x"")
00180: AppFnToArg
00181: AppFnToArg
00182: LoadFn { code: 00171, fvars: 00003 }
00183: AppFnToArg
00184: AppFnToArg
00185: PushString("")
00186: AppFnToArg
00187: LoadVar(00000)
00188: AppFnToArg
00189: AppFnToArg
00190:   Return
00191: LoadVar(00000)
00192: PushString("")
00193: PushString("")
00194: PushString("A")
00195: AppFnToArg
00196: PushString("B")
00197: AppFnToArg
00198: AppFnToArg
00199: PushString("")
00200: PushString("C")
00201: AppFnToArg
00202: PushString("D")
00203: AppFnToArg
00204: AppFnToArg
00205: AppFnToArg
00206:   Return
00207: LoadFn { code: 00135, fvars: 00000 }
00208: PushString(""flatten"")
00209: AppFnToArg
00210: LoadFn { code: 00139, fvars: 00000 }
00211: PushString(""xs"")
00212: AppFnToArg
00213: LoadFn { code: 00173, fvars: 00002 }
00214: AppFnToArg
00215: AppFnToArg
00216: LoadFn { code: 00191, fvars: 00000 }
00217: AppFnToArg
00218:   Return
00219: LoadFn { code: 00097, fvars: 00000 }
00220: PushString(""reverse"")
00221: AppFnToArg
00222: LoadFn { code: 00101, fvars: 00000 }
00223: PushString(""xs"")
00224: AppFnToArg
00225: LoadFn { code: 00113, fvars: 00001 }
00226: AppFnToArg
00227: AppFnToArg
00228: LoadFn { code: 00207, fvars: 00001 }
00229: AppFnToArg
00230:   Return
00231: LoadFn { code: 00016, fvars: 00000 }
00232: PushString(""fold"")
00233: AppFnToArg
00234: LoadFn { code: 00022, fvars: 00000 }
00235: PushString(""fold"")
00236: AppFnToArg
00237: LoadFn { code: 00079, fvars: 00000 }
00238: AppFnToArg
00239: AppFnToArg
00240: LoadFn { code: 00219, fvars: 00000 }
00241: AppFnToArg
00242:   Return

[A, B, C, D]

---

:fold = (:fold ~> { [:f, :acc, :xs] => {
    __unpack(xs, [:xs, :x] => {
        fold(f, f(acc, x), xs)
    }, {
        acc
    })
}})
:reverse = (:xs => {
    fold([:xs, :x] => { xs(x) }, [], xs)
})
:destructure = (:destructure ~> { [:acc, :compound] => {
    __unpack(compound, [:xs, :x] => {
        destructure(acc(x), xs)
    }, {
        [compound, reverse(acc)]
    })
} })([])
destructure(Foo(Bar, Baz, Qux))

(=
  :fold
  (~>
    :fold
    { (=>
        ([]
          :f
          :acc
          :xs)
        { (__unpack
            xs
            (=>
              ([]
                :xs
                :x)
              { (fold
                  f
                  (f
                    acc
                    x)
                  xs) })
            { acc }) }) }))
(=
  :reverse
  (=>
    :xs
    { (fold
        (=>
          ([]
            :xs
            :x)
          { (xs
              x) })
        []
        xs) }))
(=
  :destructure
  ((~>
    :destructure
    { (=>
        ([]
          :acc
          :compound)
        { (__unpack
            compound
            (=>
              ([]
                :xs
                :x)
              { (destructure
                  (acc
                    x)
                  xs) })
            { ([]
                compound
                (reverse
                  acc)) }) }) })
    []))
(destructure
  (Foo
    Bar
    Baz
    Qux))

( ( ( =>
        =>
          =>
            ( 0
              1 )
      "fold" )
    ( ( =>
          =>
            ~>
              0
        "fold" )
      =>
        ( ( =>
              =>
                0
            ( ( ( []
                  "f" )
                "acc" )
              "xs" ) )
          =>
            =>
              =>
                ( ( ( =>
                        =>
                          =>
                            ( pop
                              2
                              1
                              0 )
                      0 )
                    ( ( =>
                          =>
                            0
                        ( ( []
                            "xs" )
                          "x" ) )
                      =>
                        =>
                          ( ( ( 5
                                4 )
                              ( ( 4
                                  3 )
                                0 ) )
                            1 ) ) )
                  =>
                    2 ) ) ) )
  =>
    ( ( ( =>
            =>
              =>
                ( 0
                  1 )
          "reverse" )
        ( ( =>
              =>
                0
            "xs" )
          =>
            ( ( ( 1
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "xs" )
                        "x" ) )
                    =>
                      =>
                        ( 1
                          0 ) ) )
                [] )
              0 ) ) )
      =>
        ( ( ( =>
                =>
                  =>
                    ( 0
                      1 )
              "destructure" )
            ( ( ( =>
                    =>
                      ~>
                        0
                  "destructure" )
                =>
                  ( ( =>
                        =>
                          0
                      ( ( []
                          "acc" )
                        "compound" ) )
                    =>
                      =>
                        ( ( ( =>
                                =>
                                  =>
                                    ( pop
                                      2
                                      1
                                      0 )
                              0 )
                            ( ( =>
                                  =>
                                    0
                                ( ( []
                                    "xs" )
                                  "x" ) )
                              =>
                                =>
                                  ( ( 4
                                      ( 3
                                        0 ) )
                                    1 ) ) )
                          =>
                            ( ( []
                                1 )
                              ( 4
                                2 ) ) ) ) )
              [] ) )
          =>
            ( 0
              ( ( ( Foo
                    Bar )
                  Baz )
                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(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(00002)
00029: LoadVar(00001)
00030: LoadVar(00000)
00031: Unpack
00032: AppArgToFn
00033: AppArgToFn
00034:   Return
00035: LoadFn { code: 00028, fvars: 00002 }
00036:   Return
00037: LoadFn { code: 00035, fvars: 00001 }
00038:   Return
00039: LoadVar(00000)
00040:   Return
00041: LoadFn { code: 00039, fvars: 00000 }
00042:   Return
00043: LoadVar(00005)
00044: LoadVar(00004)
00045: AppFnToArg
00046: LoadVar(00004)
00047: LoadVar(00003)
00048: AppFnToArg
00049: LoadVar(00000)
00050: AppFnToArg
00051: AppFnToArg
00052: LoadVar(00001)
00053: AppFnToArg
00054:   Return
00055: LoadFn { code: 00043, fvars: 00005 }
00056:   Return
00057: LoadVar(00002)
00058:   Return
00059: LoadFn { code: 00037, fvars: 00000 }
00060: LoadVar(00000)
00061: AppFnToArg
00062: LoadFn { code: 00041, fvars: 00000 }
00063: PushString("")
00064: PushString(""xs"")
00065: AppFnToArg
00066: PushString(""x"")
00067: AppFnToArg
00068: AppFnToArg
00069: LoadFn { code: 00055, fvars: 00004 }
00070: AppFnToArg
00071: AppFnToArg
00072: LoadFn { code: 00057, fvars: 00002 }
00073: AppFnToArg
00074:   Return
00075: LoadFn { code: 00059, fvars: 00003 }
00076:   Return
00077: LoadFn { code: 00075, fvars: 00002 }
00078:   Return
00079: LoadFn { code: 00026, fvars: 00000 }
00080: PushString("")
00081: PushString(""f"")
00082: AppFnToArg
00083: PushString(""acc"")
00084: AppFnToArg
00085: PushString(""xs"")
00086: AppFnToArg
00087: AppFnToArg
00088: LoadFn { code: 00077, fvars: 00001 }
00089: AppFnToArg
00090:   Return
00091: LoadVar(00000)
00092: LoadVar(00001)
00093: AppFnToArg
00094:   Return
00095: LoadFn { code: 00091, fvars: 00001 }
00096:   Return
00097: LoadFn { code: 00095, fvars: 00000 }
00098:   Return
00099: LoadVar(00000)
00100:   Return
00101: LoadFn { code: 00099, fvars: 00000 }
00102:   Return
00103: LoadVar(00000)
00104:   Return
00105: LoadFn { code: 00103, fvars: 00000 }
00106:   Return
00107: LoadVar(00001)
00108: LoadVar(00000)
00109: AppFnToArg
00110:   Return
00111: LoadFn { code: 00107, fvars: 00001 }
00112:   Return
00113: LoadVar(00001)
00114: LoadFn { code: 00105, fvars: 00000 }
00115: PushString("")
00116: PushString(""xs"")
00117: AppFnToArg
00118: PushString(""x"")
00119: AppFnToArg
00120: AppFnToArg
00121: LoadFn { code: 00111, fvars: 00000 }
00122: AppFnToArg
00123: AppFnToArg
00124: PushString("")
00125: AppFnToArg
00126: LoadVar(00000)
00127: AppFnToArg
00128:   Return
00129: LoadVar(00000)
00130: LoadVar(00001)
00131: AppFnToArg
00132:   Return
00133: LoadFn { code: 00129, fvars: 00001 }
00134:   Return
00135: LoadFn { code: 00133, fvars: 00000 }
00136:   Return
00137: LoadVar(00000)
00138: LoadFn { code: 00000, fvars: 00000 }
00139: AppArgToFn
00140:   Return
00141: LoadFn { code: 00137, fvars: 00000 }
00142:   Return
00143: LoadVar(00000)
00144:   Return
00145: LoadFn { code: 00143, fvars: 00000 }
00146:   Return
00147: LoadVar(00002)
00148: LoadVar(00001)
00149: LoadVar(00000)
00150: Unpack
00151: AppArgToFn
00152: AppArgToFn
00153:   Return
00154: LoadFn { code: 00147, fvars: 00002 }
00155:   Return
00156: LoadFn { code: 00154, fvars: 00001 }
00157:   Return
00158: LoadVar(00000)
00159:   Return
00160: LoadFn { code: 00158, fvars: 00000 }
00161:   Return
00162: LoadVar(00004)
00163: LoadVar(00003)
00164: LoadVar(00000)
00165: AppFnToArg
00166: AppFnToArg
00167: LoadVar(00001)
00168: AppFnToArg
00169:   Return
00170: LoadFn { code: 00162, fvars: 00004 }
00171:   Return
00172: PushString("")
00173: LoadVar(00001)
00174: AppFnToArg
00175: LoadVar(00004)
00176: LoadVar(00002)
00177: AppFnToArg
00178: AppFnToArg
00179:   Return
00180: LoadFn { code: 00156, fvars: 00000 }
00181: LoadVar(00000)
00182: AppFnToArg
00183: LoadFn { code: 00160, fvars: 00000 }
00184: PushString("")
00185: PushString(""xs"")
00186: AppFnToArg
00187: PushString(""x"")
00188: AppFnToArg
00189: AppFnToArg
00190: LoadFn { code: 00170, fvars: 00003 }
00191: AppFnToArg
00192: AppFnToArg
00193: LoadFn { code: 00172, fvars: 00004 }
00194: AppFnToArg
00195:   Return
00196: LoadFn { code: 00180, fvars: 00003 }
00197:   Return
00198: LoadFn { code: 00145, fvars: 00000 }
00199: PushString("")
00200: PushString(""acc"")
00201: AppFnToArg
00202: PushString(""compound"")
00203: AppFnToArg
00204: AppFnToArg
00205: LoadFn { code: 00196, fvars: 00002 }
00206: AppFnToArg
00207:   Return
00208: LoadVar(00000)
00209: PushString("Foo")
00210: PushString("Bar")
00211: AppFnToArg
00212: PushString("Baz")
00213: AppFnToArg
00214: PushString("Qux")
00215: AppFnToArg
00216: AppFnToArg
00217:   Return
00218: LoadFn { code: 00135, fvars: 00000 }
00219: PushString(""destructure"")
00220: AppFnToArg
00221: LoadFn { code: 00141, fvars: 00000 }
00222: PushString(""destructure"")
00223: AppFnToArg
00224: LoadFn { code: 00198, fvars: 00001 }
00225: AppFnToArg
00226: PushString("")
00227: AppFnToArg
00228: AppFnToArg
00229: LoadFn { code: 00208, fvars: 00000 }
00230: AppFnToArg
00231:   Return
00232: LoadFn { code: 00097, fvars: 00000 }
00233: PushString(""reverse"")
00234: AppFnToArg
00235: LoadFn { code: 00101, fvars: 00000 }
00236: PushString(""xs"")
00237: AppFnToArg
00238: LoadFn { code: 00113, fvars: 00001 }
00239: AppFnToArg
00240: AppFnToArg
00241: LoadFn { code: 00218, fvars: 00000 }
00242: AppFnToArg
00243:   Return
00244: LoadFn { code: 00016, fvars: 00000 }
00245: PushString(""fold"")
00246: AppFnToArg
00247: LoadFn { code: 00022, fvars: 00000 }
00248: PushString(""fold"")
00249: AppFnToArg
00250: LoadFn { code: 00079, fvars: 00000 }
00251: AppFnToArg
00252: AppFnToArg
00253: LoadFn { code: 00232, fvars: 00000 }
00254: AppFnToArg
00255:   Return

[Foo, [Bar, Baz, Qux]]