Fixed the indentation of variants.

9 files changed, 75 insertions, 75 deletions

diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux
index 70623af8a..59ecb1717 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux
@@ -153,8 +153,8 @@
       (in {#Variant (if right?
                       {#.Some idx}
                       #.None)
-           (|> (dictionary.empty n.hash)
-               (dictionary.has idx value_coverage))}))))
+                    (|> (dictionary.empty n.hash)
+                        (dictionary.has idx value_coverage))}))))
 
 (def: (xor left right)
   (-> Bit Bit Bit)
@@ -270,7 +270,7 @@
 
                                 _
                                 allA)
-                     casesM})))))
+                              casesM})))))
 
     [{#Seq leftA rightA} {#Seq leftSF rightSF}]
     (case [(coverage/= leftSF leftA) (coverage/= rightSF rightA)]
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux
index c0733c07a..5b1ba0a7b 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux
@@ -96,7 +96,7 @@
           (<| (\ ! each (.function (_ [scope bodyA])
                           {#/.Function (list\each (|>> /.variable)
                                                   (//scope.environment scope))
-                           bodyA}))
+                                       bodyA}))
               /.with_scope
               ... Functions have access not only to their argument, but
               ... also to themselves, through a local variable.
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux
index 47768945d..68fafe17f 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux
@@ -87,7 +87,7 @@
     (^template [<tag>]
       [{<tag> env quantified}
        {<tag> (list\each (replace parameter_idx replacement) env)
-        (replace (n.+ 2 parameter_idx) replacement quantified)}])
+              (replace (n.+ 2 parameter_idx) replacement quantified)}])
     ([#.UnivQ]
      [#.ExQ])
     
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux
index 2b3e9f411..cb737d36d 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux
@@ -98,7 +98,7 @@
                                                                  (|>> (revised@ #.counter ++)
                                                                       (revised@ #.mappings (plist.has name [ref_type (product.left ref+inner)]))))
                                                               scope)
-                                             (product.right ref+inner)}]))
+                                                    (product.right ref+inner)}]))
                                       [init_ref #.End]
                                       (list.reversed inner))
                scopes (list\composite inner' outer)]
@@ -127,7 +127,7 @@
           (case (value@ #.scopes state')
             {#.Item head' tail'}
             (let [scopes' {#.Item (with@ #.locals (value@ #.locals head) head')
-                           tail'}]
+                                  tail'}]
               {#try.Success [[bundle' (with@ #.scopes scopes' state')]
                              output]})
 
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux
index bc9151306..f9cf0b336 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux
@@ -162,7 +162,7 @@
 (def: .public (inheritance_relationship_type class super_class super_interfaces)
   (-> .Type .Type (List .Type) .Type)
   {#.Primitive ..inheritance_relationship_type_name
-   (list& class super_class super_interfaces)})
+               (list& class super_class super_interfaces)})
 
 ... TODO: Get rid of this template block and use the definition in
 ... lux/ffi.jvm.lux ASAP
@@ -419,7 +419,7 @@
         [_ (typeA.infer ..int)
          arrayA (typeA.with_type {#.Primitive (|> (jvm.array primitive_type)
                                                   ..reflection)
-                                  (list)}
+                                              (list)}
                   (analyse archive arrayC))]
         (in {#/////analysis.Extension extension_name (list arrayA)}))
 
@@ -453,7 +453,7 @@
         [lengthA (typeA.with_type ..int
                    (analyse archive lengthC))
          _ (typeA.infer {#.Primitive (|> (jvm.array primitive_type) ..reflection)
-                         (list)})]
+                                     (list)})]
         (in {#/////analysis.Extension extension_name (list lengthA)}))
 
       _
@@ -485,7 +485,7 @@
   (-> .Type (Operation (Type Parameter)))
   (case objectT
     (^ {#.Primitive (static array.type_name)
-        (list elementT)})
+                    (list elementT)})
     (/////analysis.except ..non_parameter objectT)
     
     {#.Primitive name parameters}
@@ -571,7 +571,7 @@
               (phase\in (jvm.class name (list)))))
     
     (^ {#.Primitive (static array.type_name)
-        (list elementT)})
+                    (list elementT)})
     (|> elementT
         check_jvm
         (phase\each jvm.array))
@@ -625,7 +625,7 @@
          idxA (typeA.with_type ..int
                 (analyse archive idxC))
          arrayA (typeA.with_type {#.Primitive (|> (jvm.array jvm_type) ..reflection)
-                                  (list)}
+                                              (list)}
                   (analyse archive arrayC))]
         (in {#/////analysis.Extension extension_name (list idxA arrayA)}))
 
@@ -657,7 +657,7 @@
 (def: (write_primitive_array_handler lux_type jvm_type)
   (-> .Type (Type Primitive) Handler)
   (let [array_type {#.Primitive (|> (jvm.array jvm_type) ..reflection)
-                    (list)}]
+                                (list)}]
     (function (_ extension_name analyse archive args)
       (case args
         (^ (list idxC valueC arrayC))
@@ -886,7 +886,7 @@
                   #.None
                   (if (java/lang/reflect/Modifier::isInterface (java/lang/Class::getModifiers source_class))
                     {#.Item (:as java/lang/reflect/Type (ffi.class_for java/lang/Object))
-                     (array.list #.None (java/lang/Class::getGenericInterfaces source_class))}
+                            (array.list #.None (java/lang/Class::getGenericInterfaces source_class))}
                     (array.list #.None (java/lang/Class::getGenericInterfaces source_class)))))))
 
 (def: (inheritance_candidate_parents class_loader fromT target_class toT fromC)
@@ -1458,11 +1458,11 @@
                                  (undefined))]
          outputJT (check_return outputT)]
         (in {#/////analysis.Extension extension_name
-             (list& (/////analysis.text (..signature (jvm.class class_name (list))))
-                    (/////analysis.text method)
-                    (/////analysis.text (..signature outputJT))
-                    objectA
-                    (decorate_inputs argsT argsA))})))]))
+                                      (list& (/////analysis.text (..signature (jvm.class class_name (list))))
+                                             (/////analysis.text method)
+                                             (/////analysis.text (..signature outputJT))
+                                             objectA
+                                             (decorate_inputs argsT argsA))})))]))
 
 (def: (invoke::constructor class_loader)
   (-> java/lang/ClassLoader Handler)
@@ -1967,24 +1967,24 @@
         
         2
         {#/////analysis.Case (/////analysis.unit)
-         [[#/////analysis.when
-           {#/////analysis.Bind 2}
+                             [[#/////analysis.when
+                               {#/////analysis.Bind 2}
                                
-           #/////analysis.then
-           bodyA]
-          (list)]}
+                               #/////analysis.then
+                               bodyA]
+                              (list)]}
 
         _
         {#/////analysis.Case (/////analysis.unit)
-         [[#/////analysis.when
-           {#/////analysis.Complex
-            {#/////analysis.Tuple (|> arity
-                                      list.indices
-                                      (list\each (|>> (n.+ 2) #/////analysis.Bind)))}}
+                             [[#/////analysis.when
+                               {#/////analysis.Complex
+                                {#/////analysis.Tuple (|> arity
+                                                          list.indices
+                                                          (list\each (|>> (n.+ 2) #/////analysis.Bind)))}}
                                
-           #/////analysis.then
-           bodyA]
-          (list)]})))
+                               #/////analysis.then
+                               bodyA]
+                              (list)]})))
 
 (def: .public (analyse_overriden_method analyse archive selfT mapping supers method)
   (-> Phase Archive .Type Mapping (List (Type Class)) (Overriden_Method Code) (Operation Analysis))
@@ -2169,10 +2169,10 @@
          _ (..require_complete_method_concretion class_loader supers methods)
          methodsA (monad.each ! (analyse_overriden_method analyse archive selfT mapping supers) methods)]
         (in {#/////analysis.Extension extension_name
-             (list (class_analysis super_class)
-                   (/////analysis.tuple (list\each class_analysis super_interfaces))
-                   (/////analysis.tuple (list\each typed_analysis constructor_argsA+))
-                   (/////analysis.tuple methodsA))})))]))
+                                      (list (class_analysis super_class)
+                                            (/////analysis.tuple (list\each class_analysis super_interfaces))
+                                            (/////analysis.tuple (list\each typed_analysis constructor_argsA+))
+                                            (/////analysis.tuple methodsA))})))]))
 
 (def: (bundle::class class_loader)
   (-> java/lang/ClassLoader Bundle)
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/host.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/host.lux
index 6d5f5fdd5..0fb66d830 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/host.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/host.lux
@@ -27,7 +27,7 @@
       ["[0]" reference]
       ["//" common_lisp "_"
        ["[1][0]" runtime {"+" [Operation Phase Handler Bundle
-                             with_vars]}]]]
+                               with_vars]}]]]
      ["/[1]" // "_"
       ["[0]" generation]
       ["//[1]" /// "_"
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux
index 994a9f33f..15a73026e 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux
@@ -132,7 +132,7 @@
                                                                                  (apply (n.+ ..this_offset arity_inputs) additional_inputs)
                                                                                  _.areturn))
 
-... (i.< over_extent (.int stage))
+                                                                           ... (i.< over_extent (.int stage))
                                                                            (let [current_environment (|> (list.indices (list.size environment))
                                                                                                          (list\each (///foreign.get class))
                                                                                                          (monad.all _.monad))
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux
index 50b89c2e2..6722a4e4e 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux
@@ -119,7 +119,7 @@
       [_
        {#/.Alt old_left old_right}]
       {#/.Alt old_left
-       (weave new old_right)}
+              (weave new old_right)}
 
       [{#/.Seq preN postN}
        {#/.Seq preO postO}]
@@ -137,30 +137,30 @@
        {#/.Bit_Fork old_when old_then old_else}]
       (if (bit\= new_when old_when)
         {#/.Bit_Fork old_when
-         (weave new_then old_then)
-         (case [new_else old_else]
-           [#.None #.None]
-           #.None
+                     (weave new_then old_then)
+                     (case [new_else old_else]
+                       [#.None #.None]
+                       #.None
 
-           (^or [{#.Some woven_then} #.None]
-                [#.None {#.Some woven_then}])
-           {#.Some woven_then}
+                       (^or [{#.Some woven_then} #.None]
+                            [#.None {#.Some woven_then}])
+                       {#.Some woven_then}
 
-           [{#.Some new_else} {#.Some old_else}]
-           {#.Some (weave new_else old_else)})}
+                       [{#.Some new_else} {#.Some old_else}]
+                       {#.Some (weave new_else old_else)})}
         {#/.Bit_Fork old_when
-         (case new_else
-           #.None
-           old_then
-
-           {#.Some new_else}
-           (weave new_else old_then))
-         {#.Some (case old_else
-                   #.None
-                   new_then
-
-                   {#.Some old_else}
-                   (weave new_then old_else))}})
+                     (case new_else
+                       #.None
+                       old_then
+
+                       {#.Some new_else}
+                       (weave new_else old_then))
+                     {#.Some (case old_else
+                               #.None
+                               new_then
+
+                               {#.Some old_else}
+                               (weave new_then old_else))}})
 
       (^template [<tag> <equivalence>]
         [[{<tag> new_fork} {<tag> old_fork}]
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux
index 757bdb4c3..17399b478 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux
@@ -40,29 +40,29 @@
   (function (recur path)
     (case path
       {#/.Seq {#/.Bind register}
-       post}
+              post}
       (if (n.= redundant register)
         (recur post)
         {#/.Seq {#/.Bind (if (n.> redundant register)
                            (-- register)
                            register)}
-         (recur post)})
+                (recur post)})
 
       (^or {#/.Seq {#/.Access {#/.Member member}}
-            {#/.Seq {#/.Bind register}
-             post}}
+                   {#/.Seq {#/.Bind register}
+                           post}}
            ... This alternative form should never occur in practice.
            ... Yet, it is "technically" possible to construct it.
            {#/.Seq {#/.Seq {#/.Access {#/.Member member}}
-                    {#/.Bind register}}
-            post})
+                           {#/.Bind register}}
+                   post})
       (if (n.= redundant register)
         (recur post)
         {#/.Seq {#/.Access {#/.Member member}}
-         {#/.Seq {#/.Bind (if (n.> redundant register)
-                            (-- register)
-                            register)}
-          (recur post)}})
+                {#/.Seq {#/.Bind (if (n.> redundant register)
+                                   (-- register)
+                                   register)}
+                        (recur post)}})
 
       (^template [<tag>]
         [{<tag> left right}
@@ -132,8 +132,8 @@
                     {#/.Branch (case branch
                                  {#/.Let input register output}
                                  {#/.Let (recur input)
-                                  (..prune redundant register)
-                                  (recur output)}
+                                         (..prune redundant register)
+                                         (recur output)}
                                  
                                  {#/.If test then else}
                                  {#/.If (recur test) (recur then) (recur else)}
@@ -373,8 +373,8 @@
             (in [(dictionary.lacks register redundancy)
                  {#/.Control (if redundant?
                                {#/.Branch {#/.Case input
-                                           {#/.Seq #/.Pop
-                                            {#/.Then (..remove_local register output)}}}}
+                                                   {#/.Seq #/.Pop
+                                                           {#/.Then (..remove_local register output)}}}}
                                {#/.Branch {#/.Let input register output}})}]))
           
           {#/.If test then else}