WIP: JVM function generation.

18 files changed, 549 insertions, 35 deletions

diff --git a/documentation/research/text_editor & ide.md b/documentation/research/text_editor & ide.md
index 433644c7a..4fc5ad04a 100644
--- a/documentation/research/text_editor & ide.md
+++ b/documentation/research/text_editor & ide.md
@@ -188,6 +188,7 @@
 
 ## Structured editing
 
+1. [Tiled Text](http://www.tiledtext.com/projects/tiledtext)
 1. [Deuce: A Lightweight User Interface for Structured Editing](https://arxiv.org/abs/1707.00015)
 1. ["Structured Editing for Elm* in Elm" by Ravi Chugh](https://www.youtube.com/watch?v=-TFL6E1uSHE)
 1. [The TeXmacs user interface and structured text editing](https://www.youtube.com/watch?v=Sc55nOSN0kQ)
diff --git a/stdlib/source/lux/data/collection/list.lux b/stdlib/source/lux/data/collection/list.lux
index 1e00ee529..cec488e95 100644
--- a/stdlib/source/lux/data/collection/list.lux
+++ b/stdlib/source/lux/data/collection/list.lux
@@ -25,7 +25,7 @@
       #.Nil
       init
 
-      (#.Cons [x xs'])
+      (#.Cons x xs')
       (fold f (f x init) xs'))))
 
 (def: #export (reverse xs)
@@ -42,7 +42,7 @@
     #.Nil
     #.Nil
     
-    (#.Cons [x xs'])
+    (#.Cons x xs')
     (if (keep? x)
       (#.Cons x (filter keep? xs'))
       (filter keep? xs'))))
@@ -57,16 +57,16 @@
     (#.Cons head tail)
     (let [[in out] (partition satisfies? tail)]
       (if (satisfies? head)
-        [(list& head in) out]
-        [in (list& head out)]))))
+        [(#.Cons head in) out]
+        [in (#.Cons head out)]))))
 
 (def: #export (as-pairs xs)
   {#.doc (doc "Cut the list into pairs of 2."
               "Caveat emptor: If the list has an uneven number of elements, the last one will be skipped.")}
   (All [a] (-> (List a) (List [a a])))
   (case xs
-    (^ (#.Cons [x1 (#.Cons [x2 xs'])]))
-    (#.Cons [[x1 x2] (as-pairs xs')])
+    (^ (list& x1 x2 xs'))
+    (#.Cons [x1 x2] (as-pairs xs'))
 
     _
     #.Nil))
@@ -80,11 +80,11 @@
          #.Nil
          #.Nil
          
-         (#.Cons [x xs'])
+         (#.Cons x xs')
          <then>)
        <else>))]
   
-  [take (#.Cons [x (take (dec n) xs')]) #.Nil]
+  [take (#.Cons x (take (dec n) xs')) #.Nil]
   [drop (drop (dec n) xs') xs]
   )
 
@@ -96,12 +96,12 @@
        #.Nil
        #.Nil
        
-       (#.Cons [x xs'])
+       (#.Cons x xs')
        (if (predicate x)
          <then>
          <else>)))]
 
-  [take-while (#.Cons [x (take-while predicate xs')]) #.Nil]
+  [take-while (#.Cons x (take-while predicate xs')) #.Nil]
   [drop-while (drop-while predicate xs') xs]
   )
 
@@ -113,9 +113,9 @@
       #.Nil
       [#.Nil #.Nil]
       
-      (#.Cons [x xs'])
+      (#.Cons x xs')
       (let [[tail rest] (split (dec n) xs')]
-        [(#.Cons [x tail]) rest]))
+        [(#.Cons x tail) rest]))
     [#.Nil xs]))
 
 (def: (split-with' predicate ys xs)
@@ -125,9 +125,9 @@
     #.Nil
     [ys xs]
 
-    (#.Cons [x xs'])
+    (#.Cons x xs')
     (if (predicate x)
-      (split-with' predicate (#.Cons [x ys]) xs')
+      (split-with' predicate (#.Cons x ys) xs')
       [ys xs])))
 
 (def: #export (split-with predicate xs)
@@ -153,7 +153,7 @@
   (All [a]
     (-> Nat a (List a)))
   (if (n.> 0 n)
-    (#.Cons [x (repeat (dec n) x)])
+    (#.Cons x (repeat (dec n) x))
     #.Nil))
 
 (def: (iterate' f x)
@@ -161,7 +161,7 @@
     (-> (-> a (Maybe a)) a (List a)))
   (case (f x)
     (#.Some x')
-    (list& x (iterate' f x'))
+    (#.Cons x (iterate' f x'))
 
     #.None
     (list)))
@@ -172,7 +172,7 @@
     (-> (-> a (Maybe a)) a (List a)))
   (case (f x)
     (#.Some x')
-    (list& x (iterate' f x'))
+    (#.Cons x (iterate' f x'))
 
     #.None
     (list x)))
@@ -185,7 +185,7 @@
     #.Nil
     #.None
 
-    (#.Cons [x xs'])
+    (#.Cons x xs')
     (if (predicate x)
       (#.Some x)
       (find predicate xs'))))
@@ -197,7 +197,7 @@
     #.Nil
     #.None
 
-    (#.Cons [x xs'])
+    (#.Cons x xs')
     (case (check x)
       (#.Some output)
       (#.Some output)
@@ -212,7 +212,7 @@
     #.Nil
     #.None
 
-    (#.Cons [x xs'])
+    (#.Cons x xs')
     (case (check x)
       (#.Some output)
       (#.Cons output (search-all check xs'))
@@ -228,11 +228,11 @@
     #.Nil
     xs
 
-    (#.Cons [x #.Nil])
+    (#.Cons x #.Nil)
     xs
 
-    (#.Cons [x xs'])
-    (#.Cons [x (#.Cons [sep (interpose sep xs')])])))
+    (#.Cons x xs')
+    (list& x sep (interpose sep xs'))))
 
 (def: #export (size list)
   (All [a] (-> (List a) Nat))
@@ -267,7 +267,7 @@
     #.Nil
     #.None
 
-    (#.Cons [x xs'])
+    (#.Cons x xs')
     (if (n.= 0 i)
       (#.Some x)
       (nth (dec i) xs'))))
@@ -343,11 +343,11 @@
      {#.doc "Generates an inclusive interval of values [from, to]."}
      (-> <type> <type> (List <type>))
      (cond (<lt> to from)
-           (list& from (<name> (inc from) to))
+           (#.Cons from (<name> (inc from) to))
 
            ## > GT
            (<lt> from to)
-           (list& from (<name> (dec from) to))
+           (#.Cons from (<name> (dec from) to))
 
            ## (= to from)
            (list from)))]
diff --git a/stdlib/source/lux/tool/compiler/arity.lux b/stdlib/source/lux/tool/compiler/arity.lux
index 2e6b07490..54b50cab2 100644
--- a/stdlib/source/lux/tool/compiler/arity.lux
+++ b/stdlib/source/lux/tool/compiler/arity.lux
@@ -6,9 +6,9 @@
 
 (type: #export Arity Nat)
 
-(template [<name> <comparison>]
+(template [<comparison> <name>]
   [(def: #export <name> (-> Arity Bit) (<comparison> 1))]
 
-  [mono? n.=]
-  [poly? n.>]
+  [n.= unary?]
+  [n.> multiary?]
   )
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm.lux
index 9a4847165..23f3defea 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm.lux
@@ -6,15 +6,16 @@
    [runtime (#+ Phase)]
    ["#." primitive]
    ["#." structure]
-   ## ["." reference ("#@." system)]
-   ## ["." function]
+   ["#." reference]
+   ["#." function]
    ## ["." case]
    ## ["." loop]
    ["//#" ///
     ## ["." extension]
     [//
      [analysis (#+)]
-     ["." synthesis]]]])
+     ["." synthesis]
+     ["." reference]]]])
 
 (def: #export (generate synthesis)
   Phase
@@ -33,8 +34,13 @@
     (^ (synthesis.tuple members))
     (/structure.tuple generate members)
 
-    ## (#synthesis.Reference value)
-    ## (/reference@reference value)
+    (#synthesis.Reference reference)
+    (case reference
+      (#reference.Variable variable)
+      (/reference.variable variable)
+      
+      (#reference.Constant constant)
+      (/reference.constant constant))
 
     ## (^ (synthesis.branch/case case))
     ## (/case.case generate case)
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function.lux
new file mode 100644
index 000000000..12e1bc460
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function.lux
@@ -0,0 +1,64 @@
+(.module:
+  [lux #*
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    [state (#+ State)]]
+   [data
+    [number
+     ["." i32]
+     ["n" nat]]
+    [collection
+     ["." list ("#@." monoid functor)]
+     ["." row]]]
+   [target
+    [jvm
+     ["." descriptor (#+ Descriptor Value Return)]
+     ["." modifier (#+ Modifier) ("#@." monoid)]
+     ["." field (#+ Field)]
+     ["." method (#+ Method)]
+     ["_" instruction (#+ Label Instruction) ("#@." monad)]
+     ["." constant
+      [pool (#+ Pool)]]
+     [encoding
+      [name (#+ External)]
+      ["." unsigned]]]]]
+  ["." / #_
+   ["#." abstract]
+   ["#." arity]
+   ["#." field
+    ["#/." foreign]
+    ["#/." partial
+     ["#/." count]]]
+   ["#." method #_
+    ["#/." new]
+    ["#/." reset]
+    ["#/." implementation]
+    ["#/." apply]]
+   ["/#" // #_
+    [runtime (#+ Operation Phase)]
+    ["#." value]
+    ["#." reference]
+    [////
+     [reference (#+ Register)]
+     [analysis (#+ Environment)]
+     [synthesis (#+ Synthesis Abstraction Apply)]
+     ["." arity (#+ Arity)]
+     ["." phase]]]])
+
+(def: #export (apply generate [abstractionS argsS])
+  (-> Phase Apply (Operation (Instruction Any)))
+  (do phase.monad
+    [abstractionG (generate abstractionS)
+     argsG (monad.map @ generate argsS)]
+    (wrap ($_ _.compose
+              abstractionG
+              (|> argsG
+                  (list.split-all /arity.maximum)
+                  (monad.map _.monad
+                             (function (_ batchG)
+                               ($_ _.compose
+                                   (_.checkcast /abstract.class)
+                                   (monad.seq _.monad batchG)
+                                   (_.invokevirtual /abstract.class /method/apply.name (/method/apply.type (list.size batchG)))
+                                   ))))))))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/abstract.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/abstract.lux
new file mode 100644
index 000000000..79cede3a4
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/abstract.lux
@@ -0,0 +1,4 @@
+(.module:
+  [lux #*])
+
+(def: #export class "LuxFunction")
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/arity.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/arity.lux
new file mode 100644
index 000000000..08954a7c0
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/arity.lux
@@ -0,0 +1,10 @@
+(.module:
+  [lux (#- type)
+   [target
+    [jvm
+     ["." descriptor]]]])
+
+(def: #export field "arity")
+(def: #export type descriptor.int)
+(def: #export minimum 1)
+(def: #export maximum 8)
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field.lux
new file mode 100644
index 000000000..849d9a663
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field.lux
@@ -0,0 +1,29 @@
+(.module:
+  [lux (#- type)
+   [target
+    [jvm
+     ["." modifier (#+ Modifier) ("#@." monoid)]
+     ["." field (#+ Field)]
+     ["_" instruction (#+ Instruction)]
+     [encoding
+      [name (#+ External)]]]]]
+  ["." /// #_
+   [runtime (#+ Operation)]
+   ["#." value]
+   ["#." reference]])
+
+(def: #export type ///value.type)
+
+(def: #export (field class name)
+  (-> External Text (Instruction Any))
+  ($_ _.compose
+      ///reference.this
+      (_.getfield class name ..type)
+      ))
+
+(def: #export modifier
+  (Modifier Field)
+  ($_ modifier@compose
+      field.private
+      field.final
+      ))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/foreign.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/foreign.lux
new file mode 100644
index 000000000..b4fa6727e
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/foreign.lux
@@ -0,0 +1,33 @@
+(.module:
+  [lux #*
+   [control
+    [state (#+ State)]]
+   [data
+    [collection
+     ["." list ("#@." functor)]
+     ["." row]]]
+   [target
+    [jvm
+     [descriptor (#+ Descriptor Value)]
+     ["." field (#+ Field)]
+     [constant
+      [pool (#+ Pool)]]]]]
+  ["." //
+   ["//#" /// #_
+    ["#." value]
+    ["#." reference]
+    [////
+     [analysis (#+ Environment)]]]])
+
+(def: #export (closure environment)
+  (-> Environment (List (Descriptor (Value Any))))
+  (list.repeat (list.size environment) ////value.type))
+
+(def: #export fields
+  (-> Environment (List (State Pool Field)))
+  (|>> list.enumerate
+       (list@map (function (_ [index source])
+                   (field.field //.modifier
+                                (////reference.foreign-name index)
+                                //.type
+                                (row.row))))))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/partial.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/partial.lux
new file mode 100644
index 000000000..0f3c9ced5
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/partial.lux
@@ -0,0 +1,53 @@
+(.module:
+  [lux #*
+   [abstract
+    ["." monad]]
+   [control
+    [state (#+ State)]]
+   [data
+    [number
+     ["n" nat]]
+    [collection
+     ["." list ("#@." functor)]
+     ["." row]]]
+   [target
+    [jvm
+     ["." field (#+ Field)]
+     ["_" instruction (#+ Label Instruction) ("#@." monad)]
+     [constant
+      [pool (#+ Pool)]]]]]
+  ["." / #_
+   ["#." count]
+   ["/#" //
+    ["/#" // #_
+     ["#." arity]
+     ["/#" // #_
+      ["#." reference]
+      [////
+       ["." arity (#+ Arity)]]]]]])
+
+(def: #export (initial amount)
+  (-> Nat (Instruction Any))
+  ($_ _.compose
+      (|> _.aconst-null
+          (list.repeat amount)
+          (monad.seq _.monad))
+      (_@wrap [])))
+
+(def: #export fields
+  (-> Arity (List (State Pool Field)))
+  (|>> (n.- ///arity.minimum)
+       list.indices
+       (list@map (function (_ index)
+                   (field.field //.modifier
+                                (////reference.partial-name index)
+                                //.type
+                                (row.row))))))
+
+(def: #export (new arity)
+  (-> Arity (Instruction Any))
+  (if (arity.multiary? arity)
+    ($_ _.compose
+        /count.initial
+        (initial (n.- ///arity.minimum arity)))
+    (_@wrap [])))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/partial/count.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/partial/count.lux
new file mode 100644
index 000000000..625cad78d
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/partial/count.lux
@@ -0,0 +1,27 @@
+(.module:
+  [lux (#- type)
+   [target
+    [jvm
+     ["." descriptor]
+     ["_" instruction (#+ Instruction) ("#@." monad)]
+     [encoding
+      [name (#+ External)]
+      ["." unsigned]]]]]
+  ["." //// #_
+   ["#." abstract]
+   ["/#" // #_
+    ["#." reference]]])
+
+(def: #export field "partials")
+(def: #export type descriptor.int)
+
+(def: #export initial
+  (Instruction Any)
+  (_.bipush (unsigned.u1 0)))
+
+(def: #export value
+  (Instruction Any)
+  ($_ _.compose
+      /////reference.this
+      (_.getfield ////abstract.class ..field ..type)
+      ))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method.lux
new file mode 100644
index 000000000..2fd419d18
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method.lux
@@ -0,0 +1,13 @@
+(.module:
+  [lux #*
+   [target
+    [jvm
+     ["." modifier (#+ Modifier) ("#@." monoid)]
+     ["." method (#+ Method)]]]])
+
+(def: #export modifier
+  (Modifier Method)
+  ($_ modifier@compose
+      method.public
+      method.strict
+      ))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/apply.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/apply.lux
new file mode 100644
index 000000000..3971610ff
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/apply.lux
@@ -0,0 +1,60 @@
+(.module:
+  [lux (#- type)
+   [abstract
+    ["." monad]]
+   [data
+    [number
+     ["n" nat]
+     ["." i32]]
+    [collection
+     ["." list]]]
+   [target
+    [jvm
+     ["." descriptor (#+ Descriptor Value Return)]
+     ["_" instruction (#+ Instruction) ("#@." monad)]
+     ["." constant]
+     [encoding
+      ["." unsigned]]]]]
+  ["." /// #_
+   ["#." abstract]
+   ["#." arity]
+   ["/#" // #_
+    ["#." value]
+    [////
+     [reference (#+ Register)]
+     [arity (#+ Arity)]]]])
+
+(def: #export name "apply")
+
+(def: #export (type arity)
+  (-> Arity [(List (Descriptor (Value Any))) (Descriptor (Return Any))])
+  [(list.repeat arity ////value.type)
+   ////value.type])
+
+(def: (increment by)
+  (-> Nat (Instruction Any))
+  ($_ _.compose
+      (<| _.ldc/integer constant.integer i32.i32 .i64 by)
+      _.iadd))
+
+(def: (inputs offset amount)
+  (-> Register Nat (Instruction Any))
+  ($_ _.compose
+      (|> amount
+          list.indices
+          (monad.map _.monad (|>> (n.+ offset) unsigned.u1 _.aload)))
+      (_@wrap [])
+      ))
+
+(def: #export (instruction offset amount)
+  (-> Register Nat (Instruction Any))
+  (let [arity (n.min amount ///arity.maximum)]
+    ($_ _.compose
+        (_.checkcast ///abstract.class)
+        (..inputs offset arity)
+        (_.invokevirtual ///abstract.class ..name (..type arity))
+        (if (n.> ///arity.maximum amount)
+          (instruction (n.+ ///arity.maximum offset)
+                       (n.- ///arity.maximum amount))
+          (_@wrap []))
+        )))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/implementation.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/implementation.lux
new file mode 100644
index 000000000..9b8a19b59
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/implementation.lux
@@ -0,0 +1,37 @@
+(.module:
+  [lux (#- type)
+   [control
+    [state (#+ State)]]
+   [data
+    [collection
+     ["." list]]]
+   [target
+    [jvm
+     ["." descriptor (#+ Descriptor)]
+     ["." method (#+ Method)]
+     ["_" instruction (#+ Label Instruction)]
+     [constant
+      [pool (#+ Pool)]]]]]
+  ["." //
+   ["//#" /// #_
+    ["#." value]
+    [////
+     [arity (#+ Arity)]]]])
+
+(def: #export name "impl")
+
+(def: #export (type arity)
+  (-> Arity (Descriptor descriptor.Method))
+  (descriptor.method [(list.repeat arity ////value.type)
+                      ////value.type]))
+
+(def: #export (method arity @begin body)
+  (-> Arity Label (Instruction Any) (State Pool Method))
+  (method.method //.modifier ..name
+                 (..type arity)
+                 (list)
+                 ($_ _.compose
+                     (_.set-label @begin)
+                     body
+                     _.areturn
+                     )))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/init.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/init.lux
new file mode 100644
index 000000000..0489b8f12
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/init.lux
@@ -0,0 +1,28 @@
+(.module:
+  [lux (#- type)
+   [target
+    [jvm
+     ["." descriptor (#+ Descriptor Value Return)]
+     ["_" instruction (#+ Instruction)]
+     [encoding
+      ["." unsigned]]]]]
+  ["." /// #_
+   ["#." abstract]
+   ["#." arity]
+   ["/#" // #_
+    [////
+     ["." arity (#+ Arity)]]]])
+
+(def: #export type
+  [(List (Descriptor (Value Any)))
+   (Descriptor (Return Any))]
+  [(list ///arity.type) descriptor.void])
+
+(def: #export (instruction environment-size arity)
+  (-> Nat Arity (Instruction Any))
+  (let [arity-register (inc environment-size)]
+    ($_ _.compose
+        (if (arity.unary? arity)
+          (_.bipush (unsigned.u1 0))
+          (_.iload (unsigned.u1 arity-register)))
+        (_.invokespecial ///abstract.class "<init>" ..type))))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/new.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/new.lux
new file mode 100644
index 000000000..c0bf6e44b
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/new.lux
@@ -0,0 +1,91 @@
+(.module:
+  [lux (#- type)
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    [state (#+ State)]]
+   [data
+    [number
+     ["n" nat]]
+    [collection
+     ["." list ("#@." monoid)]]]
+   [target
+    [jvm
+     ["." descriptor (#+ Descriptor Value Return)]
+     ["." modifier (#+ Modifier) ("#@." monoid)]
+     ["." field (#+ Field)]
+     ["." method (#+ Method)]
+     ["_" instruction (#+ Instruction)]
+     ["." constant
+      [pool (#+ Pool)]]
+     [encoding
+      [name (#+ External)]
+      ["." unsigned]]]]]
+  ["." //
+   ["#." init]
+   ["/#" // #_
+    ["#." arity]
+    ["#." field
+     ["#/." foreign]
+     ["#/." partial]]
+    ["/#" // #_
+     [runtime (#+ Operation)]
+     ["#." value]
+     ["#." reference]
+     [////
+      [analysis (#+ Environment)]
+      ["." arity (#+ Arity)]
+      ["." phase]]]]])
+
+(def: (arguments arity)
+  (-> Arity (List (Descriptor (Value Any))))
+  (list.repeat (dec arity) ////value.type))
+
+(def: #export (type environment arity)
+  (-> Environment Arity [(List (Descriptor (Value Any)))
+                         (Descriptor (Return Any))])
+  [(list@compose (///field/foreign.closure environment)
+                 (if (arity.multiary? arity)
+                   (list& ///arity.type (arguments arity))
+                   (list)))
+   descriptor.void])
+
+(def: #export (instance class environment arity)
+  (-> External Environment Arity (Operation (Instruction Any)))
+  (do phase.monad
+    [foreign* (monad.map @ ////reference.variable environment)]
+    (wrap ($_ _.compose
+              (_.new class)
+              _.dup
+              (monad.seq _.monad foreign*)
+              (///field/partial.new arity)
+              (_.invokespecial class "<init>" (..type environment arity))))))
+
+(def: #export (method class environment arity)
+  (-> External Environment Arity (State Pool Method))
+  (let [after-this (: (-> Nat Nat)
+                      (n.+ 1))
+        environment-size (list.size environment)
+        after-environment (: (-> Nat Nat)
+                             (|>> after-this (n.+ environment-size)))
+        after-arity (: (-> Nat Nat)
+                       (|>> after-environment (n.+ 1)))]
+    (method.method //.modifier "<init>"
+                   (descriptor.method (..type environment arity))
+                   (list)
+                   ($_ _.compose
+                       ////reference.this
+                       (//init.instruction environment-size arity)
+                       (monad.map _.monad (function (_ register)
+                                            ($_ _.compose
+                                                ////reference.this
+                                                (_.aload (unsigned.u1 (after-this register)))
+                                                (_.putfield class (////reference.foreign-name register) ////value.type)))
+                                  (list.indices environment-size))
+                       (monad.map _.monad (function (_ register)
+                                            ($_ _.compose
+                                                ////reference.this
+                                                (_.aload (unsigned.u1 (after-arity register)))
+                                                (_.putfield class (////reference.partial-name register) ////value.type)))
+                                  (list.indices (n.- ///arity.minimum arity)))
+                       _.areturn))))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/reset.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/reset.lux
new file mode 100644
index 000000000..7aee9e428
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/method/reset.lux
@@ -0,0 +1,58 @@
+(.module:
+  [lux (#- type)
+   [abstract
+    ["." monad]]
+   [control
+    [state (#+ State)]]
+   [data
+    [collection
+     ["." list]]]
+   [target
+    [jvm
+     [modifier (#+ Modifier)]
+     ["." descriptor (#+ Descriptor)]
+     ["." method (#+ Method)]
+     ["_" instruction]
+     [constant
+      [pool (#+ Pool)]]
+     [encoding
+      [name (#+ External)]]]]]
+  ["." //
+   ["#." new]
+   ["/#" // #_
+    ["#." arity]
+    ["#." field
+     ["#/." partial]]
+    ["/#" // #_
+     ["#." value]
+     ["#." reference]
+     [////
+      [analysis (#+ Environment)]
+      [reference (#+ Register)]
+      ["." arity (#+ Arity)]]]]])
+
+(def: #export name "reset")
+
+(def: #export type
+  (-> External (Descriptor descriptor.Method))
+  (|>> descriptor.object [(list)] descriptor.method))
+
+(def: #export (method class environment arity)
+  (-> External Environment Arity (State Pool Method))
+  (method.method //.modifier ..name
+                 (..type class)
+                 (list)
+                 ($_ _.compose
+                     (if (arity.multiary? arity)
+                       ($_ _.compose
+                           (_.new class)
+                           _.dup
+                           (monad.map _.monad (function (_ source)
+                                                ($_ _.compose
+                                                    ////reference.this
+                                                    (_.getfield class (////reference.foreign-name source) ////value.type)))
+                                      (list.indices (list.size environment)))
+                           (///field/partial.new arity)
+                           (_.invokespecial class "<init>" (//new.type environment arity)))
+                       ////reference.this)
+                     _.areturn)))
diff --git a/stdlib/source/test/lux/target/jvm.lux b/stdlib/source/test/lux/target/jvm.lux
index 18469e74e..4dd3ee4b3 100644
--- a/stdlib/source/test/lux/target/jvm.lux
+++ b/stdlib/source/test/lux/target/jvm.lux
@@ -131,7 +131,7 @@
                                                                        /method.public
                                                                        /method.static)
                                                                    method-name
-                                                                   (/descriptor.method inputsJT outputJT)
+                                                                   (/descriptor.method [inputsJT outputJT])
                                                                    (list)
                                                                    (do /instruction.monad
                                                                      [_ (/instruction.ldc/long (/constant.long expected))