- Re-named "@abstraction" to ":abstraction" and "@representation" to ":representation".

1 files changed, 26 insertions, 26 deletions

diff --git a/stdlib/source/lux/lang/host/scheme.lux b/stdlib/source/lux/lang/host/scheme.lux
index f6e7b1834..adc8504bb 100644
--- a/stdlib/source/lux/lang/host/scheme.lux
+++ b/stdlib/source/lux/lang/host/scheme.lux
@@ -27,9 +27,9 @@
     {#mandatory (List Var)
      #rest (Maybe Var)})
 
-  (def: #export code (-> Code Text) (|>> @representation))
+  (def: #export code (-> Code Text) (|>> :representation))
 
-  (def: #export var (-> Text Var) (|>> @abstraction))
+  (def: #export var (-> Text Var) (|>> :abstraction))
 
   (def: (arguments [vars rest])
     (-> Arguments Code)
@@ -40,33 +40,33 @@
         rest
 
         _
-        (|> (format " . " (@representation rest))
+        (|> (format " . " (:representation rest))
             (format (|> vars
                         (list/map ..code)
                         (text.join-with " ")))
             (text.enclose ["(" ")"])
-            @abstraction))
+            :abstraction))
       
       #.None
       (|> vars
           (list/map ..code)
           (text.join-with " ")
           (text.enclose ["(" ")"])
-          @abstraction)))
+          :abstraction)))
 
   (def: #export nil
     Computation
-    (@abstraction "'()"))
+    (:abstraction "'()"))
 
   (def: #export bool
     (-> Bool Computation)
     (|>> (case> true "#t"
                 false "#f")
-         @abstraction))
+         :abstraction))
 
   (def: #export int
     (-> Int Computation)
-    (|>> %i @abstraction))
+    (|>> %i :abstraction))
 
   (def: #export float
     (-> Frac Computation)
@@ -81,7 +81,7 @@
                 
                 ## else
                 [%f])
-         @abstraction))
+         :abstraction))
 
   (def: #export positive-infinity Computation (..float number.positive-infinity))
   (def: #export negative-infinity Computation (..float number.negative-infinity))
@@ -89,15 +89,15 @@
 
   (def: #export string
     (-> Text Computation)
-    (|>> %t @abstraction))
+    (|>> %t :abstraction))
 
   (def: #export symbol
     (-> Text Computation)
-    (|>> (format "'") @abstraction))
+    (|>> (format "'") :abstraction))
 
   (def: #export global
     (-> Text Global)
-    (|>> @abstraction))
+    (|>> :abstraction))
 
   (def: form
     (-> (List Code) Text)
@@ -107,7 +107,7 @@
   
   (def: #export (apply/* func args)
     (-> Expression (List Expression) Computation)
-    (@abstraction (..form (#.Cons func args))))
+    (:abstraction (..form (#.Cons func args))))
   
   (do-template [<name> <function>]
     [(def: #export <name>
@@ -223,7 +223,7 @@
   (do-template [<lux-name> <scheme-name>]
     [(def: #export <lux-name>
        (-> (List Expression) Computation)
-       (|>> (list& (..global <scheme-name>)) ..form @abstraction))]
+       (|>> (list& (..global <scheme-name>)) ..form :abstraction))]
 
     [or "or"]
     [and "and"]
@@ -232,15 +232,15 @@
   (do-template [<lux-name> <scheme-name> <var> <pre>]
     [(def: #export (<lux-name> bindings body)
        (-> (List [<var> Expression]) Expression Computation)
-       (@abstraction
+       (:abstraction
         (..form (list (..global <scheme-name>)
                       (|> bindings
                           (list/map (.function (_ [binding/name binding/value])
-                                      (@abstraction
+                                      (:abstraction
                                        (..form (list (<pre> binding/name)
                                                      binding/value)))))
                           ..form
-                          @abstraction)
+                          :abstraction)
                       body))))]
 
     [let           "let"           Var       .id]
@@ -253,12 +253,12 @@
 
   (def: #export (if test then else)
     (-> Expression Expression Expression Computation)
-    (@abstraction
+    (:abstraction
      (..form (list (..global "if") test then else))))
 
   (def: #export (when test then)
     (-> Expression Expression Computation)
-    (@abstraction
+    (:abstraction
      (..form (list (..global "when") test then))))
 
   (def: #export (cond clauses else)
@@ -267,19 +267,19 @@
                      (if test then next))
                    else
                    (list.reverse clauses))
-        @representation
-        @abstraction))
+        :representation
+        :abstraction))
 
   (def: #export (lambda arguments body)
     (-> Arguments Expression Computation)
-    (@abstraction
+    (:abstraction
      (..form (list (..global "lambda")
                    (..arguments arguments)
                    body))))
 
   (def: #export (define name arguments body)
     (-> Var Arguments Expression Computation)
-    (@abstraction
+    (:abstraction
      (..form (list (..global "define")
                    (|> arguments
                        (update@ #mandatory (|>> (#.Cons name)))
@@ -288,15 +288,15 @@
 
   (def: #export begin
     (-> (List Expression) Computation)
-    (|>> (#.Cons (..global "begin")) ..form @abstraction))
+    (|>> (#.Cons (..global "begin")) ..form :abstraction))
 
   (def: #export (set! name value)
     (-> Var Expression Computation)
-    (@abstraction
+    (:abstraction
      (..form (list (..global "set!") name value))))
 
   (def: #export (with-exception-handler handler body)
     (-> Expression Expression Computation)
-    (@abstraction
+    (:abstraction
      (..form (list (..global "with-exception-handler") handler body))))
   )