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

1 files changed, 20 insertions, 20 deletions

diff --git a/new-luxc/source/luxc/lang/host/common-lisp.lux b/new-luxc/source/luxc/lang/host/common-lisp.lux
index 3ba69314d..108f69e27 100644
--- a/new-luxc/source/luxc/lang/host/common-lisp.lux
+++ b/new-luxc/source/luxc/lang/host/common-lisp.lux
@@ -16,18 +16,18 @@
 
   Text
 
-  (def: name (All [k] (-> (Var k) Text)) (|>> @representation))
+  (def: name (All [k] (-> (Var k) Text)) (|>> :representation))
 
-  (def: #export var (-> Text (Var Single)) (|>> @abstraction))
+  (def: #export var (-> Text (Var Single)) (|>> :abstraction))
 
   (def: #export (poly vars)
     (-> (List (Var Single)) (Var Poly))
-    (@abstraction
+    (:abstraction
      (format "(" (|> vars (list/map ..name) (text.join-with " ")) ")")))
 
   (def: #export (poly+ vars rest)
     (-> (List (Var Single)) (Var Single) (Var Poly))
-    (@abstraction
+    (:abstraction
      (format "(" (|> vars (list/map ..name) (text.join-with " "))
              " &rest " (..name rest)
              ")")))
@@ -42,24 +42,24 @@
   
   Text
 
-  (def: #export expression (-> Expression Text) (|>> @representation))
+  (def: #export expression (-> Expression Text) (|>> :representation))
 
-  (def: #export code (-> Text Expression) (|>> @abstraction))
+  (def: #export code (-> Text Expression) (|>> :abstraction))
 
   (type: #export Lambda [PVar Expression])
 
   (def: #export nil
     Expression
-    (@abstraction "()"))
+    (:abstraction "()"))
 
   (def: #export bool
     (-> Bool Expression)
-    (|>> (case> true (@abstraction "t")
+    (|>> (case> true (:abstraction "t")
                 false ..nil)))
 
   (def: #export int
     (-> Int Expression)
-    (|>> %i @abstraction))
+    (|>> %i :abstraction))
 
   (def: #export float
     (-> Frac Expression)
@@ -74,11 +74,11 @@
                 
                 ## else
                 [%f])
-         @abstraction))
+         :abstraction))
 
   (def: #export (double value)
     (-> Frac Expression)
-    (@abstraction
+    (:abstraction
      (.cond (f/= number.positive-infinity value)
             "(/ 1.0d0 0.0d0)"
             
@@ -100,24 +100,24 @@
 
   (def: #export string
     (-> Text Expression)
-    (|>> %t @abstraction))
+    (|>> %t :abstraction))
 
   (do-template [<name> <prefix>]
     [(def: #export <name>
        (-> Text Expression)
-       (|>> (format <prefix>) @abstraction))]
+       (|>> (format <prefix>) :abstraction))]
 
     [symbol "'"]
     [keyword ":"])
 
   (def: #export (form elements)
     (-> (List Expression) Expression)
-    (@abstraction
+    (:abstraction
      (format "(" (|> elements (list/map expression) (text.join-with " ")) ")")))
 
   (def: #export @@
     (All [k] (-> (Var k) Expression))
-    (|>> ..name @abstraction))
+    (|>> ..name :abstraction))
 
   (def: #export global
     (-> Text Expression)
@@ -350,15 +350,15 @@
          expression
          
          (#.Cons single #.Nil)
-         (@abstraction
-          (format <prefix> single " " (@representation expression)))
+         (:abstraction
+          (format <prefix> single " " (:representation expression)))
          
          _
-         (@abstraction
+         (:abstraction
           (format <prefix> (|> conditions (list/map ..symbol)
                                (.list& (..symbol "or")) ..form
-                               @representation)
-                  " " (@representation expression)))))]
+                               :representation)
+                  " " (:representation expression)))))]
 
     [conditional+ "#+"]
     [conditional- "#-"])