Got rid of Object-Oriented Programming modules.

3 files changed, 50 insertions, 756 deletions

diff --git a/stdlib/source/lux/type/object/interface.lux b/stdlib/source/lux/type/object/interface.lux
deleted file mode 100644
index fb2579d55..000000000
--- a/stdlib/source/lux/type/object/interface.lux
+++ /dev/null
@@ -1,515 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    ["." monad (#+ do Monad)]
-    ["p" parser ("parser/." Monad<Parser>)]]
-   [data
-    ["." product]
-    ["." maybe]
-    [name ("name/." Equivalence<Name>)]
-    ["." text
-     format]
-    [collection
-     ["." list ("list/." Functor<List> Fold<List> Monoid<List>)]
-     ["." set (#+ Set)]]]
-   ["." type]
-   ["." macro (#+ Monad<Meta>) ("meta/." Monad<Meta>)
-    ["." code]
-    ["s" syntax (#+ syntax:)]
-    [syntax
-     ["cs" common]
-     [common
-      ["csr" reader]
-      ["csw" writer]]]]])
-
-## [Common]
-(type: Declaration
-  [Text (List Text)])
-
-(type: Alias Text)
-
-(def: default-alias Alias "@")
-
-(def: (var-set vars)
-  (-> (List Text) (Set Text))
-  (set.from-list text.Hash<Text> vars))
-
-(def: (unique-type-vars parser)
-  (-> (s.Syntax (List Text)) (s.Syntax (List Text)))
-  (do p.Monad<Parser>
-    [raw parser
-     _ (p.assert "Cannot repeat the names of type variables/parameters."
-                 (n/= (set.size (var-set raw))
-                      (list.size raw)))]
-    (wrap raw)))
-
-(def: (safe-type-vars exclusions)
-  (-> (Set Text) (s.Syntax Text))
-  (do p.Monad<Parser>
-    [raw s.local-symbol
-     _ (p.assert "Cannot re-use names between method type-variables and interface type-parameters."
-                 (|> raw (set.member? exclusions) not))]
-    (wrap raw)))
-
-(def: declarationS
-  (s.Syntax Declaration)
-  (p.either (s.form (p.seq s.local-symbol
-                           (unique-type-vars (p.some s.local-symbol))))
-            (p.seq s.local-symbol
-                   (parser/wrap (list)))))
-
-(def: aliasS
-  (s.Syntax Alias)
-  (|> s.local-symbol
-      (p.after (s.this (' #as)))
-      (p.default default-alias)))
-
-(def: (ancestor-inputs ancestors)
-  (-> (List Name) (List Code))
-  (if (list.empty? ancestors)
-    (list)
-    (|> (list.size ancestors)
-        dec
-        (list.n/range +0)
-        (list/map (|>> %n (format "ancestor") code.local-symbol)))))
-
-## [Methods]
-(type: Method
-  {#type-vars (List Text)
-   #name Text
-   #inputs (List Code)
-   #output Code})
-
-(def: (method exclusions)
-  (-> (Set Text) (s.Syntax Method))
-  (s.form ($_ p.seq
-              (p.either (unique-type-vars (s.tuple (p.some (safe-type-vars exclusions))))
-                        (parser/wrap (list)))
-              s.local-symbol
-              (s.tuple (p.some s.any))
-              s.any)))
-
-(def: (declarationM g!self (^open "."))
-  (-> Code Method Code)
-  (let [g!type-vars (list/map code.local-symbol type-vars)
-        g!method (code.local-symbol name)]
-    (` (: (All [(~+ g!type-vars)]
-            (-> (~+ inputs) (~ g!self) (~ output)))
-          (~ g!method)))))
-
-(def: (definition export [interface parameters] g!self-object g!ext g!states (^open "."))
-  (-> Bit Declaration Code Code (List Code) Method Code)
-  (let [g!method (code.local-symbol name)
-        g!parameters (list/map code.local-symbol parameters)
-        g!type-vars (list/map code.local-symbol type-vars)
-        g!_temp (code.symbol ["" "_temp"])
-        g!_object (code.symbol ["" "_object"])
-        g!_behavior (code.symbol ["" "_behavior"])
-        g!_state (code.symbol ["" "_state"])
-        g!_extension (code.symbol ["" "_extension"])
-        g!_args (list/map (|>> product.left .int %i (format "_") code.local-symbol)
-                          (list.enumerate inputs))
-        g!destructuring (list/fold (function (_ _ g!bottom) (` [(~ g!_temp) (~ g!_temp) (~ g!bottom)]))
-                                   (` [(~ g!_behavior) (~ g!_state) (~ g!_extension)])
-                                   (maybe.default g!states (list.tail g!states)))]
-    (` (def: (~+ (csw.export export)) ((~ g!method) (~+ g!_args) (~ g!_object))
-         (All [(~+ g!parameters) (~ g!ext) (~+ g!states) (~+ g!type-vars)]
-           (-> (~+ inputs) (~ g!self-object) (~ output)))
-         (let [(~ g!destructuring) (~ g!_object)]
-           (:: (~ g!_behavior) (~ g!method) (~+ g!_args) (~ g!_object)))))))
-
-## [Inheritance]
-(type: Reference
-  [Name (List Code)])
-
-(def: no-parent Name ["" ""])
-
-(def: (no-parent? parent)
-  (-> Name Bit)
-  (name/= no-parent parent))
-
-(def: (with-interface parent interface)
-  (-> Name Name cs.Annotations cs.Annotations)
-  (|>> (#.Cons [(name-for #..interface-name)
-                (code.tag interface)])
-       (#.Cons [(name-for #..interface-parent)
-                (code.tag parent)])))
-
-(def: (with-class interface parent class)
-  (-> Name Name Name cs.Annotations cs.Annotations)
-  (|>> (#.Cons [(name-for #..class-interface)
-                (code.tag interface)])
-       (#.Cons [(name-for #..class-parent)
-                (code.tag parent)])
-       (#.Cons [(name-for #..class-name)
-                (code.tag class)])))
-
-(do-template [<name> <name-tag> <parent-tag> <desc>]
-  [(def: (<name> name)
-     (-> Name (Meta [Name (List Name)]))
-     (do Monad<Meta>
-       [[_ annotations _] (macro.find-def name)]
-       (case [(macro.get-tag-ann (name-for <name-tag>) annotations)
-              (macro.get-tag-ann (name-for <parent-tag>) annotations)]
-         [(#.Some real-name) (#.Some parent)]
-         (if (name/= no-parent parent)
-           (wrap [real-name (list)])
-           (do @
-             [[_ ancestors] (<name> parent)]
-             (wrap [real-name (#.Cons parent ancestors)])))
-
-         _
-         (macro.fail (format "Wrong format for " <desc> " lineage.")))))]
-
-  [interfaceN #..interface-name #..interface-parent "interface"]
-  [classN     #..class-name     #..class-parent     "class"]
-  )
-
-(def: (extract newT)
-  (-> Type (Meta [Nat (List Type)]))
-  (loop [depth +0
-         currentT newT]
-    (case currentT
-      (#.UnivQ _ bodyT)
-      (recur (inc depth) bodyT)
-
-      (#.Function inputT outputT)
-      (let [[stateT+ objectT] (type.flatten-function currentT)]
-        (meta/wrap [depth stateT+]))
-
-      _
-      (macro.fail (format "Cannot extract inheritance from type: " (type.to-text newT))))))
-
-(def: (specialize mappings typeC)
-  (-> (List Code) Code Code)
-  (case (list.size mappings)
-    +0
-    typeC
-    
-    size
-    (|> (dec size)
-        (list.n/range +0)
-        (list/map (|>> (n/* +2) inc code.nat (~) #.Parameter (`)))
-        (list.zip2 (list.reverse mappings))
-        (list/fold (function (_ [mappingC parameterC] genericC)
-                     (code.replace parameterC mappingC genericC))
-                   typeC))))
-
-(def: referenceS
-  (s.Syntax Reference)
-  (p.either (s.form (p.seq s.symbol
-                           (p.some s.any)))
-            (p.seq s.symbol
-                   (parser/wrap (list)))))
-
-(do-template [<name> <keyword>]
-  [(def: <name>
-     (s.Syntax Reference)
-     (|> referenceS
-         (p.after (s.this (' <keyword>)))))]
-
-  [extension   #super]
-  [inheritance #super]
-  )
-
-## [Notation]
-## Utils
-(def: (nest ancestors bottom)
-  (-> (List Code) Code Code)
-  (list/fold (function (_ [level _] g!bottom)
-               (let [g!_behavior' (code.local-symbol (format "_behavior" (%n level)))
-                     g!_state' (code.local-symbol (format "_state" (%n level)))]
-                 (` [(~ g!_behavior') (~ g!_state') (~ g!bottom)])))
-             bottom
-             (list.enumerate ancestors)))
-
-## Names
-(do-template [<name> <category>]
-  [(def: (<name> base)
-     (-> Text Text)
-     (|> base (format <category> "@")))]
-  
-  [newN    "new"]
-  [getN    "get"]
-  [setN    "set"]
-  [updateN "update"]
-  )
-
-(do-template [<name> <category>]
-  [(def: (<name> raw)
-     (-> Text Text)
-     (let [[module kind] (name-for <category>)]
-       (format "{" kind "@" module "}" raw)))]
-
-  [signatureN #..Signature]
-  [stateN     #..State]
-  [structN    #..Struct]
-  )
-
-(def: (getterN export interface g!parameters g!ext g!child ancestors)
-  (-> Bit Text (List Code) Code Code (List Name)
-      Code)
-  (let [g!get (code.local-symbol (getN interface))
-        g!interface (code.local-symbol interface)
-        g!_object (' _object)
-        g!_behavior (' _behavior)
-        g!_state (' _state)
-        g!_extension (' _extension)
-        g!ancestors (ancestor-inputs ancestors)
-        g!object (` ((~ g!interface) (~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)))
-        g!tear-down (nest g!ancestors
-                          (` [(~ g!_behavior) (~ g!_state) (~ g!_extension)]))]
-    (` (def: (~+ (csw.export export)) ((~ g!get) (~ g!_object))
-         (All [(~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)]
-           (-> (~ g!object) (~ g!child)))
-         (let [(~ g!tear-down) (~ g!_object)]
-           (~ g!_state))))))
-
-(def: (setterN export interface g!parameters g!ext g!child ancestors)
-  (-> Bit Text (List Code) Code Code (List Name)
-      Code)
-  (let [g!set (code.local-symbol (setN interface))
-        g!interface (code.local-symbol interface)
-        g!_object (' _object)
-        g!_behavior (' _behavior)
-        g!_state (' _state)
-        g!_extension (' _extension)
-        g!_input (' _input)
-        g!ancestors (ancestor-inputs ancestors)
-        g!object (` ((~ g!interface) (~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)))
-        g!tear-down (nest g!ancestors
-                          (` [(~ g!_behavior) (~ g!_state) (~ g!_extension)]))
-        g!build-up (nest g!ancestors
-                         (` [(~ g!_behavior) (~ g!_input) (~ g!_extension)]))]
-    (` (def: (~+ (csw.export export))
-         ((~ g!set) (~ g!_input) (~ g!_object))
-         (All [(~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)]
-           (-> (~ g!child) (~ g!object) (~ g!object)))
-         (let [(~ g!tear-down) (~ g!_object)]
-           (~ g!build-up))))))
-
-(def: (updaterN export interface g!parameters g!ext g!child ancestors)
-  (-> Bit Text (List Code) Code Code (List Name)
-      Code)
-  (let [g!update (code.local-symbol (updateN interface))
-        g!interface (code.local-symbol interface)
-        g!_object (' _object)
-        g!_behavior (' _behavior)
-        g!_state (' _state)
-        g!_extension (' _extension)
-        g!_change (' _change)
-        g!ancestors (ancestor-inputs ancestors)
-        g!object (` ((~ g!interface) (~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)))
-        g!tear-down (nest g!ancestors
-                          (` [(~ g!_behavior) (~ g!_state) (~ g!_extension)]))
-        g!build-up (nest g!ancestors
-                         (` [(~ g!_behavior) ((~ g!_change) (~ g!_state)) (~ g!_extension)]))]
-    (` (def: (~+ (csw.export export))
-         ((~ g!update) (~ g!_change) (~ g!_object))
-         (All [(~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)]
-           (-> (-> (~ g!child) (~ g!child))
-               (-> (~ g!object) (~ g!object))))
-         (let [(~ g!tear-down) (~ g!_object)]
-           (~ g!build-up))))))
-
-## [Macros]
-(def: (type-to-code type)
-  (-> Type (Meta Code))
-  (case type
-    (#.Primitive name params)
-    (do Monad<Meta>
-      [paramsC+ (monad.map @ type-to-code params)]
-      (wrap (` (.primitive (~ (code.symbol ["" name]))
-                           (~+ paramsC+)))))
-
-    (^template [<tag> <macro> <flatten>]
-      (<tag> _)
-      (do Monad<Meta>
-        [partsC+ (monad.map @ type-to-code (<flatten> type))]
-        (wrap (` (<macro> (~+ partsC+))))))
-    ([#.Sum     .| type.flatten-variant]
-     [#.Product .& type.flatten-tuple])
-
-    (#.Function input output)
-    (do Monad<Meta>
-      [#let [[insT+ outT] (type.flatten-function type)]
-       insC+ (monad.map @ type-to-code insT+)
-       outC (type-to-code outT)]
-      (wrap (` (.-> (~+ insC+) (~ outC)))))
-
-    (^template [<tag>]
-      (<tag> idx)
-      (meta/wrap (` (<tag> (~ (code.nat idx))))))
-    ([#.Parameter]
-     [#.Var]
-     [#.Ex])
-
-    (#.Apply param fun)
-    (do Monad<Meta>
-      [#let [[funcT argsT+] (type.flatten-application type)]
-       funcC (type-to-code funcT)
-       argsC+ (monad.map @ type-to-code argsT+)]
-      (wrap (` ((~ funcC) (~+ argsC+)))))
-
-    (#.Named name unnamedT)
-    (meta/wrap (code.symbol name))
-
-    _
-    (macro.fail (format "Cannot convert type to code: " (type.to-text type)))))
-
-(syntax: #export (interface:
-                   {export csr.export}
-                   {(^@ decl [interface parameters]) declarationS}
-                   {?extends (p.maybe extension)}
-                   {alias aliasS}
-                   {annotations (p.default cs.empty-annotations csr.annotations)}
-                   {methods (p.many (method (var-set parameters)))})
-  (macro.with-gensyms [g!self-class g!child g!ext]
-    (do @
-      [module macro.current-module-name
-       [parent ancestors mappings] (: (Meta [Name (List Name) (List Code)])
-                                      (case ?extends
-                                        #.None
-                                        (wrap [no-parent (list) (list)])
-
-                                        (#.Some [super mappings])
-                                        (do @
-                                          [[parent ancestors] (interfaceN super)]
-                                          (wrap [parent (list& parent ancestors) mappings]))))
-       #let [g!signature (code.local-symbol (signatureN interface))
-             g!interface (code.local-symbol interface)
-             g!parameters (list/map code.local-symbol parameters)
-             g!self-ref (if (list.empty? g!parameters)
-                          (list g!interface)
-                          (list))
-             g!interface-def (if (no-parent? parent)
-                               (let [g!recur (` ((~ g!interface) (~+ g!parameters) (~ g!ext) (~ g!child)))]
-                                 (` (Ex (~+ g!self-ref) [(~ g!ext) (~ g!child)]
-                                      [((~ g!signature) (~+ g!parameters) (~ g!recur))
-                                       (~ g!child)
-                                       (~ g!ext)])))
-                               (let [g!parent (code.symbol parent)
-                                     g!ancestors (ancestor-inputs ancestors)
-                                     g!recur (` ((~ g!interface) (~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)))]
-                                 (` (Ex (~+ g!self-ref) [(~ g!ext) (~+ g!ancestors) (~ g!child)]
-                                      ((~ g!parent) (~+ mappings)
-                                       [((~ g!signature) (~+ g!parameters) (~ g!recur))
-                                        (~ g!child)
-                                        (~ g!ext)]
-                                       (~+ g!ancestors))))))]]
-      (wrap (list& (` (signature: (~+ (csw.export export))
-                        ((~ g!signature) (~+ g!parameters) (~ g!self-class))
-                        (~+ (let [de-alias (code.replace (code.local-symbol alias) g!self-class)]
-                              (list/map (|>> (update@ #inputs (list/map de-alias))
-                                             (update@ #output de-alias)
-                                             (declarationM g!self-class))
-                                        methods)))))
-                   
-                   (` (type: (~+ (csw.export export)) ((~ g!interface) (~+ g!parameters))
-                        (~ (|> annotations
-                               (with-interface parent [module interface])
-                               csw.annotations))
-                        (~ g!interface-def)))
-                   
-                   (getterN export interface g!parameters g!ext g!child ancestors)
-                   (setterN export interface g!parameters g!ext g!child ancestors)
-                   (updaterN export interface g!parameters g!ext g!child ancestors)
-
-                   (let [g!ancestors (ancestor-inputs ancestors)
-                         g!states (list/compose g!ancestors (list g!child))
-                         g!self-object (` ((~ g!interface) (~+ g!parameters) (~ g!ext) (~+ g!ancestors) (~ g!child)))
-                         de-alias (code.replace (code.symbol ["" alias]) g!self-object)]
-                     (list/map (|>> (update@ #inputs (list/map de-alias))
-                                    (update@ #output de-alias)
-                                    (definition export decl g!self-object g!ext g!states))
-                               methods))))
-      )))
-
-(syntax: #export (class:
-                   {export csr.export}
-                   {[instance parameters] declarationS}
-                   {annotations (p.default cs.empty-annotations csr.annotations)}
-                   {[interface interface-mappings] referenceS}
-                   {super (p.maybe inheritance)}
-                   state-type
-                   {impls (p.many s.any)})
-  (macro.with-gensyms [g!init g!extension]
-    (do @
-      [module macro.current-module-name
-       [interface _] (interfaceN interface)
-       [parent ancestors parent-mappings] (: (Meta [Name (List Name) (List Code)])
-                                             (case super
-                                               (#.Some [super-class super-mappings])
-                                               (do @
-                                                 [[parent ancestors] (classN super-class)]
-                                                 (wrap [parent ancestors super-mappings]))
-
-                                               #.None
-                                               (wrap [no-parent (list) (list)])))
-       g!inheritance (: (Meta (List Code))
-                        (if (no-parent? parent)
-                          (wrap (list))
-                          (do @
-                            [newT (macro.find-def-type (product.both id newN parent))
-                             [depth rawT+] (extract newT)
-                             codeT+ (monad.map @ type-to-code rawT+)]
-                            (wrap (list/map (specialize parent-mappings) codeT+)))))
-       #let [g!parameters (list/map code.local-symbol parameters)
-
-             g!state (code.local-symbol (stateN instance))
-             g!struct (code.local-symbol (structN instance))
-             g!class (code.local-symbol instance)
-
-             g!signature (code.symbol (product.both id signatureN interface))
-             g!interface (code.symbol interface)
-
-             g!parent-structs (if (no-parent? parent)
-                                (list)
-                                (list/map (|>> (product.both id structN) code.symbol) (list& parent ancestors)))]
-       g!parent-inits (monad.map @ (function (_ _) (macro.gensym "parent-init"))
-                                 g!parent-structs)
-       #let [g!full-init (list/fold (function (_ [parent-struct parent-state] child)
-                                      (` [(~ parent-struct) (~ parent-state) (~ child)]))
-                                    (` [(~ g!struct) (~ g!init) []])
-                                    (list.zip2 g!parent-structs g!parent-inits))
-             g!new (code.local-symbol (newN instance))
-             g!recur (` ((~ g!class) (~+ g!parameters) (~ g!extension)))
-             g!rec (if (list.empty? g!parameters)
-                     (list (' #rec))
-                     (list))]]
-      (wrap (list (` (type: (~+ (csw.export export))
-                       ((~ g!state) (~+ g!parameters))
-                       (~ state-type)))
-
-                  (` (type: (~+ (csw.export export)) (~+ g!rec) ((~ g!class) (~+ g!parameters))
-                       (~ (|> annotations
-                              (with-class interface parent [module instance])
-                              csw.annotations))
-                       (Ex [(~ g!extension)]
-                         (~ (if (no-parent? parent)
-                              (` ((~ g!interface) (~+ interface-mappings)
-                                  (~ g!extension)
-                                  ((~ g!state) (~+ g!parameters))))
-                              (let [g!parent (code.symbol parent)]
-                                (` ((~ g!parent) (~+ parent-mappings)
-                                    [((~ g!signature) (~+ interface-mappings) (~ g!recur))
-                                     ((~ g!state) (~+ g!parameters))
-                                     (~ g!extension)]))))))))
-
-                  (` (structure: (~+ (csw.export export)) (~ g!struct)
-                       (All [(~+ g!parameters) (~ g!extension)]
-                         ((~ g!signature) (~+ interface-mappings)
-                          ((~ g!interface) (~+ interface-mappings)
-                           (~ g!extension)
-                           (~+ g!inheritance)
-                           ((~ g!state) (~+ g!parameters)))))
-                       (~+ impls)))
-
-                  (` (def: (~+ (csw.export export)) ((~ g!new) (~+ g!parent-inits) (~ g!init))
-                       (All [(~+ g!parameters)]
-                         (-> (~+ g!inheritance)
-                             ((~ g!state) (~+ g!parameters))
-                             ((~ g!class) (~+ g!parameters))))
-                       (~ g!full-init)))
-                  ))
-      )))
diff --git a/stdlib/source/lux/type/object/protocol.lux b/stdlib/source/lux/type/object/protocol.lux
deleted file mode 100644
index 26045f50f..000000000
--- a/stdlib/source/lux/type/object/protocol.lux
+++ /dev/null
@@ -1,158 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    ["p" parser]
-    ["." monad (#+ do)]]
-   [data
-    ["." sum]
-    [collection
-     [list ("list/." Functor<List>)]]]
-   ["." macro ("meta/." Monad<Meta>)
-    ["." code]
-    ["s" syntax (#+ syntax:)]
-    [syntax
-     ["cs" common]
-     [common
-      ["csr" reader]
-      ["csw" writer]]]]])
-
-(type: #export (Method i o)
-  (All [r] [i (-> o r)]))
-
-(type: #export (Message i o)
-  (Method i o o))
-
-(def: #export (message input)
-  (All [i o] (-> i (Message i o)))
-  [input id])
-
-(type: #export (Class s p)
-  (All [r] (-> (p r) s [r s])))
-
-(type: #export (Alt lp rp)
-  (All [r] (| (lp r) (rp r))))
-
-(def: #export (alt left right)
-  (All [s lp rp]
-    (-> (Class s lp)
-        (Class s rp)
-        (Class s (Alt lp rp))))
-  (function (_ input state)
-    (case input
-      (#.Left input)
-      (left input state)
-
-      (#.Right input)
-      (right input state))))
-
-(type: #export (Object p)
-  (All [r] (-> (p r) [r (Object p)])))
-
-(def: #export (object class init)
-  (All [s p] (-> (Class s p) s (Object p)))
-  (loop [state init]
-    (function (_ input)
-      (let [[output state'] (class input state)]
-        [output (recur state')]))))
-
-(type: Method-Syntax
-  {#method-variables (List Text)
-   #method-name Text
-   #method-input Code
-   #method-output Code})
-
-(def: method|r
-  (s.Syntax Method-Syntax)
-  (s.form ($_ p.seq
-              (p.default (list) csr.type-variables)
-              s.local-symbol
-              s.any
-              s.any)))
-
-(def: (method|w g!return method)
-  (-> Code Method-Syntax Code)
-  (let [tagC (code.local-tag (get@ #method-name method))
-        varsC+ (csw.type-variables (get@ #method-variables method))
-        inputC (get@ #method-input method)
-        outputC (get@ #method-output method)]
-    (` ((~ tagC) (All [(~+ varsC+)]
-                   (Method (~ inputC) (~ outputC) (~ g!return)))))))
-
-(def: (method|c export protocol method)
-  (-> Bit cs.Declaration Method-Syntax (Meta Code))
-  (let [methodC (code.local-symbol (get@ #method-name method))
-        tagC (code.local-tag (get@ #method-name method))
-        protocolC (code.local-symbol (get@ #cs.declaration-name protocol))
-        protocol-varsC+ (csw.type-variables (get@ #cs.declaration-args protocol))
-        method-varsC+ (csw.type-variables (get@ #method-variables method))
-        method-inputC (get@ #method-input method)
-        method-outputC (get@ #method-output method)]
-    (macro.with-gensyms [g!input g!return]
-      (meta/wrap (` (def: (~+ (csw.export export)) ((~ methodC) (~ g!input))
-                      (All [(~+ protocol-varsC+) (~+ method-varsC+)]
-                        (-> (~ method-inputC)
-                            ((~ protocolC) (~+ protocol-varsC+) (~ method-outputC))))
-                      ((~ tagC) [(~ g!input) .id])))))))
-
-(type: Class-Syntax
-  {#class-name Text
-   #class-protocol Code})
-
-(def: class|r
-  (s.Syntax Class-Syntax)
-  (s.form ($_ p.seq
-              s.local-symbol
-              s.any)))
-
-(def: (class|w g!return class)
-  (-> Code Class-Syntax Code)
-  (let [tagC (code.local-tag (get@ #class-name class))
-        protocolC (get@ #class-protocol class)]
-    (` ((~ tagC) ((~ protocolC) (~ g!return))))))
-
-(def: (class|c export protocol class)
-  (-> Bit cs.Declaration Class-Syntax (Meta Code))
-  (let [classC (code.local-symbol (get@ #class-name class))
-        tagC (code.local-tag (get@ #class-name class))
-        protocolC (code.local-symbol (get@ #cs.declaration-name protocol))
-        protocol-varsC+ (csw.type-variables (get@ #cs.declaration-args protocol))
-        class-protocolC (get@ #class-protocol class)]
-    (macro.with-gensyms [g!sub g!return]
-      (meta/wrap (` (def: (~+ (csw.export export)) ((~ classC) (~ g!sub))
-                      (All [(~+ protocol-varsC+)]
-                        (-> (~ class-protocolC)
-                            ((~ protocolC) (~+ protocol-varsC+))))
-                      ((~ tagC) (~ g!sub))))))))
-
-(type: Super-Syntax
-  (#Method Method-Syntax)
-  (#Class Class-Syntax))
-
-(def: super|r
-  (s.Syntax Super-Syntax)
-  (p.alt method|r
-         class|r))
-
-(def: (super|w g!return)
-  (-> Code Super-Syntax Code)
-  (sum.either (method|w g!return)
-              (class|w g!return)))
-
-(def: (super|c export protocol)
-  (-> Bit cs.Declaration (| Method-Syntax Class-Syntax) (Meta Code))
-  (sum.either (method|c export protocol)
-              (class|c export protocol)))
-
-(syntax: #export (protocol:
-                   {export csr.export}
-                   {declaration csr.declaration}
-                   {supers (p.many super|r)})
-  (macro.with-gensyms [g!return]
-    (do @
-      [constructors (monad.map @ (super|c export declaration) supers)
-       #let [protocolC (code.local-symbol (get@ #cs.declaration-name declaration))
-             varsC+ (csw.type-variables (get@ #cs.declaration-args declaration))]]
-      (wrap (list& (` (type: (~+ (csw.export export))
-                        ((~ protocolC) (~+ varsC+) (~ g!return))
-                        (~+ (list/map (super|w g!return) supers))))
-                   constructors)))))
diff --git a/stdlib/source/lux/world/console.lux b/stdlib/source/lux/world/console.lux
index 2aafa9571..93365f61e 100644
--- a/stdlib/source/lux/world/console.lux
+++ b/stdlib/source/lux/world/console.lux
@@ -1,105 +1,72 @@
 (.module:
   [lux #*
-   [control [monad (#+ do)]]
+   [control
+    [monad (#+ do)]
+    ["ex" exception (#+ exception:)]]
    [data
-    ["e" error]
-    ["." text]]
+    ["." error]
+    ["." text
+     format]]
    [concurrency
     ["." promise]
     ["." task (#+ Task)]]
-   [type
-    [object
-     interface]]
    ["." io (#+ IO Process io)]
    [host (#+ import:)]])
 
-(interface: #export Console
-  (read-char [] (Task Text))
-  (read-line [] (Task Text))
-  (write [Text] (Task Any))
-  (close [] (Task Any)))
+(exception: #export (cannot-close)
+  "")
+
+(signature: #export (Console m)
+  (: (-> [] (m Nat))
+     read)
+  (: (-> [] (m Text))
+     read-line)
+  (: (-> [Text] (m Any))
+     write)
+  (: (-> [] (m Any))
+     close))
 
 (for {"JVM"
-      (as-is (import: java/io/InputStream
-               (read [] #io #try int)
-               (available [] #io #try int)
-               (mark [int] #io #try void)
-               (reset [] #io #try void))
+      (as-is (import: java/lang/String)
+
+             (import: #long java/io/Console
+               (readLine [] #io #try String))
 
-             (import: java/io/Reader)
+             (import: java/io/InputStream
+               (read [] #io #try int))
 
              (import: java/io/PrintStream
                (print [String] #io #try void))
 
              (import: java/lang/System
+               (#static console [] #io #try java/io/Console)
                (#static in java/io/InputStream)
                (#static out java/io/PrintStream))
 
-             (import: java/lang/Appendable
-               (append [CharSequence] Appendable))
-
-             (import: java/lang/String)
-
-             (import: java/lang/StringBuffer
-               (new [String])
-               (toString [] String))
-
-             (class: JVM-Console Console
-               {#input InputStream
-                #output PrintStream}
-
-               (def: read-char
-                 (|>> get@Console
-                      (get@ #input)
-                      (InputStream::read [])
-                      (:: io.Functor<Process> map (|>> .nat text.from-code))
-                      promise.future))
-               
-               (def: (read-line console)
-                 (let [input (|> console get@Console (get@ #input))
-                       buffer (StringBuffer::new [""])]
-                   (promise.future
-                    (loop [_ []]
-                      (do io.Monad<Process>
-                        [char (<| (:: @ map (|>> .nat text.from-code))
-                                  (InputStream::read [] input))]
-                        (case char
-                          "\n"
-                          (wrap (StringBuffer::toString [] buffer))
-                          
-                          "\r"
-                          (do @
-                            [available (InputStream::available [] input)]
-                            (if (i/> 0 available)
-                              (do @
-                                [_ (InputStream::mark [10] input)
-                                 next (<| (:: @ map (|>> .nat text.from-code))
-                                          (InputStream::read [] input))]
-                                (case next
-                                  "\n"
-                                  (wrap (StringBuffer::toString [] buffer))
-                                  
-                                  _
-                                  (do @
-                                    [_ (InputStream::reset [] input)]
-                                    (wrap (StringBuffer::toString [] buffer)))))
-                              (wrap (StringBuffer::toString [] buffer))))
-                          
-                          _
-                          (exec (Appendable::append [(:coerce String char)] buffer)
-                            (recur []))))))))
-               
-               (def: (write message)
-                 (|>> get@Console
-                      (get@ #output)
-                      (PrintStream::print [message])
-                      promise.future))
-               
-               (def: (close self)
-                 (task.return [])))
-
              (def: #export open
-               (Process Console)
-               (io (#e.Success (new@JVM-Console {#input System::in
-                                                 #output System::out})))))
+               (Process (Console Task))
+               (do io.Monad<Process>
+                 [jvm-console (System::console [])
+                  #let [jvm-input System::in
+                        jvm-output System::out]]
+                 (wrap (: (Console Task)
+                          (structure
+                           (def: (read _)
+                             (|> jvm-input
+                                 (InputStream::read [])
+                                 (:: io.Functor<Process> map .nat)
+                                 promise.future))
+                           
+                           (def: (read-line _)
+                             (|> jvm-console (java/io/Console::readLine []) promise.future))
+                           
+                           (def: (write message)
+                             (|> jvm-output (PrintStream::print [message]) promise.future))
+                           
+                           (def: close
+                             (|>> (ex.construct cannot-close) task.fail))))))))
       })
+
+(def: #export (write-line message console)
+  (All [m] (-> Text (Console m) (m Any)))
+  (:: console write (format message "")))