1 files changed, 53 insertions, 53 deletions

diff --git a/stdlib/source/lux/control/region.lux b/stdlib/source/lux/control/region.lux
index f1bfd2c21..3bc17e7f9 100644
--- a/stdlib/source/lux/control/region.lux
+++ b/stdlib/source/lux/control/region.lux
@@ -14,12 +14,12 @@
   [//
    ["." exception (#+ Exception exception:)]])
 
-(type: (Cleaner r m)
-  (-> r (m (Try Any))))
+(type: (Cleaner r !)
+  (-> r (! (Try Any))))
 
-(type: #export (Region r m a)
-  (-> [r (List (Cleaner r m))]
-      (m [(List (Cleaner r m))
+(type: #export (Region r ! a)
+  (-> [r (List (Cleaner r !))]
+      (! [(List (Cleaner r !))
           (Try a)])))
 
 (def: separator
@@ -47,36 +47,36 @@
     (#try.Success _)
     output
 
-    (#try.Failure error|clean-up)
-    (exception.throw ..clean-up-error [error|clean-up output])))
+    (#try.Failure error)
+    (exception.throw ..clean-up-error [error output])))
 
-(def: #export (run Monad<m> computation)
-  (All [m a]
-    (-> (Monad m) (All [r] (Region r m a))
-        (m (Try a))))
-  (do {! Monad<m>}
+(def: #export (run monad computation)
+  (All [! a]
+    (-> (Monad !) (All [r] (Region r ! a))
+        (! (Try a))))
+  (do {! monad}
     [[cleaners output] (computation [[] (list)])
      results (monad.map ! (function (_ cleaner) (cleaner []))
                         cleaners)]
     (wrap (list\fold combine-outcomes output results))))
 
-(def: #export (acquire Monad<m> cleaner value)
-  (All [m a] (-> (Monad m) (-> a (m (Try Any))) a
-                 (All [r] (Region r m a))))
+(def: #export (acquire monad cleaner value)
+  (All [! a] (-> (Monad !) (-> a (! (Try Any))) a
+                 (All [r] (Region r ! a))))
   (function (_ [region cleaners])
-    (:: Monad<m> wrap [(#.Cons (function (_ region) (cleaner value))
-                               cleaners)
-                       (#try.Success value)])))
+    (:: monad wrap [(#.Cons (function (_ region) (cleaner value))
+                            cleaners)
+                    (#try.Success value)])))
 
-(structure: #export (functor Functor<m>)
-  (All [m]
-    (-> (Functor m)
-        (All [r] (Functor (Region r m)))))
+(structure: #export (functor super)
+  (All [!]
+    (-> (Functor !)
+        (All [r] (Functor (Region r !)))))
 
   (def: (map f)
     (function (_ fa)
       (function (_ region+cleaners)
-        (:: Functor<m> map
+        (:: super map
             (function (_ [cleaners' temp])
               [cleaners' (case temp
                            (#try.Success value)
@@ -86,17 +86,17 @@
                            (#try.Failure error))])
             (fa region+cleaners))))))
 
-(structure: #export (apply Monad<m>)
-  (All [m]
-    (-> (Monad m)
-        (All [r] (Apply (Region r m)))))
+(structure: #export (apply super)
+  (All [!]
+    (-> (Monad !)
+        (All [r] (Apply (Region r !)))))
 
   (def: &functor
-    (..functor (get@ #monad.&functor Monad<m>)))
+    (..functor (get@ #monad.&functor super)))
 
   (def: (apply ff fa)
     (function (_ [region cleaners])
-      (do Monad<m>
+      (do super
         [[cleaners ef] (ff [region cleaners])
          [cleaners ea] (fa [region cleaners])]
         (case ef
@@ -111,21 +111,21 @@
           (#try.Failure error)
           (wrap [cleaners (#try.Failure error)]))))))
 
-(structure: #export (monad Monad<m>)
-  (All [m]
-    (-> (Monad m)
-        (All [r] (Monad (Region r m)))))
+(structure: #export (monad super)
+  (All [!]
+    (-> (Monad !)
+        (All [r] (Monad (Region r !)))))
 
   (def: &functor
-    (..functor (get@ #monad.&functor Monad<m>)))
+    (..functor (get@ #monad.&functor super)))
 
   (def: (wrap value)
     (function (_ [region cleaners])
-      (:: Monad<m> wrap [cleaners (#try.Success value)])))
+      (:: super wrap [cleaners (#try.Success value)])))
 
   (def: (join ffa)
     (function (_ [region cleaners])
-      (do Monad<m>
+      (do super
         [[cleaners efa] (ffa [region cleaners])]
         (case efa
           (#try.Success fa)
@@ -134,24 +134,24 @@
           (#try.Failure error)
           (wrap [cleaners (#try.Failure error)]))))))
 
-(def: #export (fail Monad<m> error)
-  (All [m a]
-    (-> (Monad m) Text
-        (All [r] (Region r m a))))
+(def: #export (fail monad error)
+  (All [! a]
+    (-> (Monad !) Text
+        (All [r] (Region r ! a))))
   (function (_ [region cleaners])
-    (:: Monad<m> wrap [cleaners (#try.Failure error)])))
-
-(def: #export (throw Monad<m> exception message)
-  (All [m e a]
-    (-> (Monad m) (Exception e) e
-        (All [r] (Region r m a))))
-  (fail Monad<m> (exception.construct exception message)))
-
-(def: #export (lift Monad<m> operation)
-  (All [m a]
-    (-> (Monad m) (m a)
-        (All [r] (Region r m a))))
+    (:: monad wrap [cleaners (#try.Failure error)])))
+
+(def: #export (throw monad exception message)
+  (All [! e a]
+    (-> (Monad !) (Exception e) e
+        (All [r] (Region r ! a))))
+  (fail monad (exception.construct exception message)))
+
+(def: #export (lift monad operation)
+  (All [! a]
+    (-> (Monad !) (! a)
+        (All [r] (Region r ! a))))
   (function (_ [region cleaners])
-    (do Monad<m>
+    (do monad
       [output operation]
       (wrap [cleaners (#try.Success output)]))))