From 0e3830be97930a01c38d8bca09a1ac9d5bf55465 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Wed, 22 Nov 2017 20:37:41 -0400 Subject: - Fixed some bugs. - Some refactoring. - Added some alternative snippets of code that new-luxc can handle better. --- stdlib/source/lux/concurrency/atom.lux | 4 +- stdlib/source/lux/concurrency/promise.lux | 24 +++++++--- stdlib/source/lux/control/applicative.lux | 17 ++++--- stdlib/source/lux/data/coll/array.lux | 26 ++++++++++- stdlib/source/lux/data/coll/dict.lux | 26 ++++++++--- stdlib/source/lux/data/coll/list.lux | 4 +- stdlib/source/lux/data/coll/sequence.lux | 45 ++++++++++++++---- stdlib/source/lux/data/number.lux | 78 +++++++++++++++---------------- stdlib/source/lux/data/text.lux | 9 +++- stdlib/source/lux/lang/type.lux | 2 +- stdlib/source/lux/macro/syntax.lux | 19 ++++---- stdlib/source/lux/math.lux | 15 +++--- stdlib/source/lux/type/opaque.lux | 42 +++++++++-------- 13 files changed, 200 insertions(+), 111 deletions(-) (limited to 'stdlib/source') diff --git a/stdlib/source/lux/concurrency/atom.lux b/stdlib/source/lux/concurrency/atom.lux index 2837d6177..f2e1cc14e 100644 --- a/stdlib/source/lux/concurrency/atom.lux +++ b/stdlib/source/lux/concurrency/atom.lux @@ -13,7 +13,7 @@ (def: #export (read atom) (All [a] (-> (Atom a) (IO a))) - (io ("lux atom get" atom))) + (io ("lux atom read" atom))) (def: #export (compare-and-swap current new atom) {#;doc "Only mutates an atom if you can present it's current value. @@ -29,7 +29,7 @@ The retries will be done with the new values of the atom, as they show up."} (All [a] (-> (-> a a) (Atom a) (IO Unit))) - (io (let [old ("lux atom get" atom)] + (io (let [old ("lux atom read" atom)] (if ("lux atom compare-and-swap" atom old (f old)) [] (io;run (update f atom)))))) diff --git a/stdlib/source/lux/concurrency/promise.lux b/stdlib/source/lux/concurrency/promise.lux index 75bcc52fd..9baaded11 100644 --- a/stdlib/source/lux/concurrency/promise.lux +++ b/stdlib/source/lux/concurrency/promise.lux @@ -89,7 +89,9 @@ (struct: #export _ (F;Functor Promise) (def: (map f fa) - (let [fb (promise ($ +1))] + (let [fb (promise ($ +1)) + ## fb (promise' #;None) + ] (exec (await (function [a] (resolve (f a) fb)) fa) fb)))) @@ -102,7 +104,9 @@ #observers (list)})) (def: (apply ff fa) - (let [fb (promise ($ +1))] + (let [fb (promise ($ +1)) + ## fb (promise' #;None) + ] (exec (await (function [f] (io (await (function [a] (resolve (f a) fb)) fa))) @@ -114,7 +118,9 @@ (def: applicative Applicative) (def: (join mma) - (let [ma (promise ($ +0))] + (let [ma (promise ($ +0)) + ## ma (promise' #;None) + ] (exec (await (function [ma'] (io (await (function [a'] (resolve a' ma)) ma'))) @@ -132,7 +138,9 @@ (def: #export (alt left right) {#;doc "Heterogeneous alternative combinator."} (All [a b] (-> (Promise a) (Promise b) (Promise (| a b)))) - (let [a|b (promise (Either ($ +0) ($ +1)))] + (let [a|b (promise (| ($ +0) ($ +1))) + ## a|b (promise' #;None) + ] (with-expansions [ (do-template [ ] [(await (function [value] (resolve ( value) a|b)) @@ -147,7 +155,9 @@ (def: #export (either left right) {#;doc "Homogeneous alternative combinator."} (All [a] (-> (Promise a) (Promise a) (Promise a))) - (let [left||right (promise ($ +0))] + (let [left||right (promise ($ +0)) + ## left||right (promise' #;None) + ] (`` (exec (~~ (do-template [] [(await (function [value] (resolve value left||right)) )] @@ -159,7 +169,9 @@ (def: #export (future computation) {#;doc "Runs an I/O computation on its own process and returns an Promise that will eventually host its result."} (All [a] (-> (IO a) (Promise a))) - (let [!out (promise ($ +0))] + (let [!out (promise ($ +0)) + ## !out (promise' #;None) + ] (exec ("lux process future" (io (io;run (resolve (io;run computation) !out)))) !out))) diff --git a/stdlib/source/lux/control/applicative.lux b/stdlib/source/lux/control/applicative.lux index 187950aa9..d2b505941 100644 --- a/stdlib/source/lux/control/applicative.lux +++ b/stdlib/source/lux/control/applicative.lux @@ -1,10 +1,10 @@ (;module: lux - (.. ["F" functor])) + (.. [functor #+ Functor])) (sig: #export (Applicative f) {#;doc "Applicative functors."} - (: (F;Functor f) + (: (Functor f) functor) (: (All [a] (-> a (f a))) @@ -16,15 +16,20 @@ (struct: #export (compose Applicative Applicative) {#;doc "Applicative functor composition."} (All [F G] (-> (Applicative F) (Applicative G) (Applicative (All [a] (F (G a)))))) - (def: functor (F;compose (get@ #functor Applicative) - (get@ #functor Applicative))) + + (def: functor (functor;compose (get@ #functor Applicative) + (get@ #functor Applicative))) (def: wrap (|>. (:: Applicative wrap) (:: Applicative wrap))) (def: (apply fgf fgx) + ## (let [fgf' (:: Applicative apply + ## (:: Applicative wrap (:: Applicative apply)) + ## fgf)] + ## (:: Applicative apply fgf' fgx)) (let [applyF (:: Applicative apply) applyG (:: Applicative apply)] ($_ applyF (:: Applicative wrap applyG) fgf - fgx))) - ) + fgx)) + )) diff --git a/stdlib/source/lux/data/coll/array.lux b/stdlib/source/lux/data/coll/array.lux index 2dbf07803..c697e5681 100644 --- a/stdlib/source/lux/data/coll/array.lux +++ b/stdlib/source/lux/data/coll/array.lux @@ -78,7 +78,19 @@ xs' (delete idx xs'))))) xs - (list;indices (size xs)))) + (list;indices (size xs))) + ## (list/fold (function [idx xs'] + ## (case (read idx xs) + ## #;None + ## xs' + + ## (#;Some x) + ## (if (p x) + ## xs' + ## (delete idx xs')))) + ## xs + ## (list;indices (size xs))) + ) (def: #export (find p xs) (All [a] @@ -195,7 +207,17 @@ (#;Some x) (write idx (f x) mb)))) (new arr-size) - (list;n.range +0 (n.dec arr-size))))))) + (list;n.range +0 (n.dec arr-size))) + ## (list/fold (function [idx mb] + ## (case (read idx ma) + ## #;None + ## mb + + ## (#;Some x) + ## (write idx (f x) mb))) + ## (new arr-size) + ## (list;n.range +0 (n.dec arr-size))) + )))) (struct: #export _ (Fold Array) (def: (fold f init xs) diff --git a/stdlib/source/lux/data/coll/dict.lux b/stdlib/source/lux/data/coll/dict.lux index d5528dc09..cee6a83fc 100644 --- a/stdlib/source/lux/data/coll/dict.lux +++ b/stdlib/source/lux/data/coll/dict.lux @@ -120,7 +120,8 @@ (def: (insert! idx value old-array) (All [a] (-> Index a (Array a) (Array a))) (let [old-size (array;size old-array)] - (|> (: (Array ($ +0)) + (|> ## (array;new (n.inc old-size)) + (: (Array ($ +0)) (array;new (n.inc old-size))) (array;copy idx +0 old-array +0) (array;write idx value) @@ -233,8 +234,10 @@ (array;write insertion-idx (#;Left sub-node) base)]]) ))) [+0 [clean-bitmap + ## (array;new (n.dec h-size)) (: (Base ($ +0) ($ +1)) - (array;new (n.dec h-size)))]] + (array;new (n.dec h-size))) + ]] (list;indices (array;size h-array))))) ## When #Base nodes grow too large, they're promoted to #Hierarchy to @@ -264,8 +267,10 @@ (undefined))] default)) [+0 + ## (array;new hierarchy-nodes-size) (: (Array (Node ($ +0) ($ +1))) - (array;new hierarchy-nodes-size))] + (array;new hierarchy-nodes-size)) + ] hierarchy-indices))) ## All empty nodes look the same (a #Base node with clean bitmap is @@ -287,13 +292,20 @@ ## a sub-node. If impossible, I introduced a new singleton sub-node. (#Hierarchy _size hierarchy) (let [idx (level-index level hash) + ## [_size' sub-node] (case (array;read idx hierarchy) + ## (#;Some sub-node) + ## [_size sub-node] + + ## _ + ## [(n.inc _size) empty]) [_size' sub-node] (: [Nat (Node ($ +0) ($ +1))] (case (array;read idx hierarchy) (#;Some sub-node) [_size sub-node] _ - [(n.inc _size) empty]))] + [(n.inc _size) empty])) + ] (#Hierarchy _size' (update! idx (put' (level-up level) hash key val Hash sub-node) hierarchy))) @@ -327,7 +339,8 @@ ## the same, a new ## #Collisions node ## is added. - (#Collisions hash (|> (: (Array [($ +0) ($ +1)]) + (#Collisions hash (|> ## (array;new +2) + (: (Array [($ +0) ($ +1)]) (array;new +2)) (array;write +0 [key' val']) (array;write +1 [key val]))) @@ -373,7 +386,8 @@ ## If the hashes are not equal, I create a new #Base node that ## contains the old #Collisions node, plus the new KV-pair. (|> (#Base (bit-position level _hash) - (|> (: (Base ($ +0) ($ +1)) + (|> ## (array;new +1) + (: (Base ($ +0) ($ +1)) (array;new +1)) (array;write +0 (#;Left node)))) (put' level hash key val Hash))) diff --git a/stdlib/source/lux/data/coll/list.lux b/stdlib/source/lux/data/coll/list.lux index 4d4090835..d7bbe0161 100644 --- a/stdlib/source/lux/data/coll/list.lux +++ b/stdlib/source/lux/data/coll/list.lux @@ -483,7 +483,9 @@ (do Monad [lMla MlMla lla (: (($ +0) (List (List ($ +1)))) - (M;seq @ lMla))] + (M;seq @ lMla)) + ## lla (M;seq @ lMla) + ] (wrap (concat lla))))) (def: #export (lift Monad) diff --git a/stdlib/source/lux/data/coll/sequence.lux b/stdlib/source/lux/data/coll/sequence.lux index f85558c5e..f76c824a7 100644 --- a/stdlib/source/lux/data/coll/sequence.lux +++ b/stdlib/source/lux/data/coll/sequence.lux @@ -74,14 +74,16 @@ (All [a] (-> Level (Base a) (Node a))) (if (n.= +0 level) (#Base tail) - (|> (: (Hierarchy ($ +0)) + (|> ## (new-hierarchy []) + (: (Hierarchy ($ +0)) (new-hierarchy [])) (array;write +0 (new-path (level-down level) tail)) #Hierarchy))) (def: (new-tail singleton) (All [a] (-> a (Base a))) - (|> (: (Base ($ +0)) + (|> ## (array;new +1) + (: (Base ($ +0)) (array;new +1)) (array;write +0 singleton))) @@ -110,7 +112,8 @@ (def: (expand-tail val tail) (All [a] (-> a (Base a) (Base a))) (let [tail-size (array;size tail)] - (|> (: (Base ($ +0)) + (|> ## (array;new (n.inc tail-size)) + (: (Base ($ +0)) (array;new (n.inc tail-size))) (array;copy tail-size +0 tail +0) (array;write tail-size val) @@ -208,7 +211,8 @@ ## If so, a brand-new root must be established, that is ## 1-level taller. (|> vec - (set@ #root (|> (: (Hierarchy ($ +0)) + (set@ #root (|> ## (new-hierarchy []) + (: (Hierarchy ($ +0)) (new-hierarchy [])) (array;write +0 (#Hierarchy (get@ #root vec))) (array;write +1 (new-path (get@ #level vec) (get@ #tail vec))))) @@ -259,8 +263,10 @@ (n.< vec-size idx)) (if (n.>= (tail-off vec-size) idx) (|> vec + ## (update@ #tail (|>. array;clone (array;write (branch-idx idx) val))) (update@ #tail (: (-> (Base ($ +0)) (Base ($ +0))) - (|>. array;clone (array;write (branch-idx idx) val))))) + (|>. array;clone (array;write (branch-idx idx) val)))) + ) (|> vec (update@ #root (put' (get@ #level vec) idx val)))) vec))) @@ -294,7 +300,26 @@ (maybe;assume (do maybe;Monad [new-tail (base-for (n.- +2 vec-size) vec) - #let [[level' root'] (: [Level (Hierarchy ($ +0))] + #let [## [level' root'] (let [init-level (get@ #level vec)] + ## (loop [level init-level + ## root (maybe;default (new-hierarchy []) + ## (pop-tail vec-size init-level (get@ #root vec))) + ## ## root (: (Hierarchy ($ +0)) + ## ## (maybe;default (new-hierarchy []) + ## ## (pop-tail vec-size init-level (get@ #root vec)))) + ## ] + ## (if (n.> branching-exponent level) + ## (case [(array;read +1 root) (array;read +0 root)] + ## [#;None (#;Some (#Hierarchy sub-node))] + ## (recur (level-down level) sub-node) + + ## ## [#;None (#;Some (#Base _))] + ## ## (undefined) + + ## _ + ## [level root]) + ## [level root]))) + [level' root'] (: [Level (Hierarchy ($ +0))] (let [init-level (get@ #level vec)] (loop [level init-level root (: (Hierarchy ($ +0)) @@ -310,7 +335,8 @@ _ [level root]) - [level root]))))]] + [level root])))) + ]] (wrap (|> vec (update@ #size n.dec) (set@ #level level') @@ -326,6 +352,7 @@ (def: #export (from-list list) (All [a] (-> (List a) (Sequence a))) (list/fold add + ## empty (: (Sequence ($ +0)) empty) list)) @@ -353,7 +380,9 @@ [(#Hierarchy h1) (#Hierarchy h2)] (:: (array;Eq (Eq Eq)) = h1 h2) - ))) + + _ + false))) (struct: #export (Eq Eq) (All [a] (-> (Eq a) (Eq (Sequence a)))) (def: (= v1 v2) diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux index 5b8e1946d..446e1e152 100644 --- a/stdlib/source/lux/data/number.lux +++ b/stdlib/source/lux/data/number.lux @@ -8,7 +8,7 @@ enum interval codec) - (data ["E" error] + (data ["e" error] [maybe] [bit]))) @@ -162,10 +162,10 @@ (def: (decode input) (case ( [input]) (#;Some value) - (#E;Success value) + (#e;Success value) #;None - (#E;Error ))))] + (#e;Error ))))] [Frac "lux frac encode" "lux frac decode" "Could not decode Frac"] ) @@ -199,16 +199,16 @@ (let [digit (maybe;assume (get-char input idx))] (case ("lux text index" digit +0) #;None - (#E;Error ("lux text concat" repr)) + (#e;Error ("lux text concat" repr)) (#;Some index) (recur (n.inc idx) (|> output (n.* ) (n.+ index))))) - (#E;Success output)))) + (#e;Success output)))) _ - (#E;Error ("lux text concat" repr))) - (#E;Error ("lux text concat" repr))))))] + (#e;Error ("lux text concat" repr))) + (#e;Error ("lux text concat" repr))))))] [Binary@Codec +2 "01" "Invalid binary syntax for Nat: "] [Octal@Codec +8 "01234567" "Invalid octal syntax for Nat: "] @@ -250,13 +250,13 @@ (let [digit (maybe;assume (get-char input idx))] (case ("lux text index" digit +0) #;None - (#E;Error ) + (#e;Error ) (#;Some index) (recur (n.inc idx) (|> output (i.* ) (i.+ (:! Int index)))))) - (#E;Success (i.* sign output))))) - (#E;Error )))))] + (#e;Success (i.* sign output))))) + (#e;Error )))))] [Binary@Codec 2 "01" "Invalid binary syntax for Int: "] [Octal@Codec 8 "01234567" "Invalid octal syntax for Int: "] @@ -289,12 +289,12 @@ (case ("lux text char" repr +0) (^multi (^ (#;Some (char "."))) [(:: decode ("lux text concat" "+" (de-prefix repr))) - (#;Some output)]) - (#E;Success (:! Deg output)) + (#e;Success output)]) + (#e;Success (:! Deg output)) _ - (#E;Error ("lux text concat" repr))) - (#E;Error ("lux text concat" repr))))))] + (#e;Error ("lux text concat" repr))) + (#e;Error ("lux text concat" repr))))))] [Binary@Codec Binary@Codec +1 "Invalid binary syntax: "] [Octal@Codec Octal@Codec +3 "Invalid octal syntax: "] @@ -327,7 +327,7 @@ decimal-part (maybe;assume ("lux text clip" repr (n.inc split-index) ("lux text size" repr)))] (case [(:: decode whole-part) (:: decode decimal-part)] - (^multi [(#;Some whole) (#;Some decimal)] + (^multi [(#e;Success whole) (#e;Success decimal)] (i.>= 0 decimal)) (let [sign (if (i.< 0 whole) -1.0 @@ -340,19 +340,19 @@ (f.* output)))) adjusted-decimal (|> decimal int-to-frac (f./ div-power)) dec-deg (case (:: Hex@Codec decode ("lux text concat" "." decimal-part)) - (#E;Success dec-deg) + (#e;Success dec-deg) dec-deg - (#E;Error error) + (#e;Error error) (error! error))] - (#E;Success (f.+ (int-to-frac whole) + (#e;Success (f.+ (int-to-frac whole) (f.* sign adjusted-decimal)))) _ - (#E;Error ("lux text concat" repr)))) + (#e;Error ("lux text concat" repr)))) _ - (#E;Error ("lux text concat" repr)))))] + (#e;Error ("lux text concat" repr)))))] [Binary@Codec Binary@Codec 2.0 "01" "Invalid binary syntax: "] ) @@ -524,14 +524,14 @@ ("lux text concat" ( whole-part)) ("lux text concat" (if (f.= -1.0 sign) "-" "")))] (case (:: Binary@Codec decode as-binary) - (#E;Error _) - (#E;Error ("lux text concat" repr)) + (#e;Error _) + (#e;Error ("lux text concat" repr)) output output)) _ - (#E;Error ("lux text concat" repr))))))] + (#e;Error ("lux text concat" repr))))))] [Octal@Codec "Invalid octaladecimal syntax: " binary-to-octal octal-to-binary] [Hex@Codec "Invalid hexadecimal syntax: " binary-to-hex hex-to-binary] @@ -543,26 +543,26 @@ (case tokens (#;Cons [meta (#;Text repr)] #;Nil) (case (:: decode repr) - (#E;Success value) - (#E;Success [state (list [meta (#;Nat value)])]) + (#e;Success value) + (#e;Success [state (list [meta (#;Nat value)])]) - (^multi (#E;Error _) - [(:: decode repr) (#E;Success value)]) - (#E;Success [state (list [meta (#;Int value)])]) + (^multi (#e;Error _) + [(:: decode repr) (#e;Success value)]) + (#e;Success [state (list [meta (#;Int value)])]) - (^multi (#E;Error _) - [(:: decode repr) (#E;Success value)]) - (#E;Success [state (list [meta (#;Deg value)])]) + (^multi (#e;Error _) + [(:: decode repr) (#e;Success value)]) + (#e;Success [state (list [meta (#;Deg value)])]) - (^multi (#E;Error _) - [(:: decode repr) (#E;Success value)]) - (#E;Success [state (list [meta (#;Frac value)])]) + (^multi (#e;Error _) + [(:: decode repr) (#e;Success value)]) + (#e;Success [state (list [meta (#;Frac value)])]) _ - (#E;Error )) + (#e;Error )) _ - (#E;Error )))] + (#e;Error )))] [bin Binary@Codec Binary@Codec Binary@Codec Binary@Codec "Invalid binary syntax." @@ -757,11 +757,11 @@ (recur (digits-sub! power digits) (n.inc idx) (bit;set (n.- idx (n.dec bit;width)) output)))) - (#E;Success (:! Deg output)))) + (#e;Success (:! Deg output)))) #;None - (#E;Error ("lux text concat" "Wrong syntax for Deg: " input))) - (#E;Error ("lux text concat" "Wrong syntax for Deg: " input)))) + (#e;Error ("lux text concat" "Wrong syntax for Deg: " input))) + (#e;Error ("lux text concat" "Wrong syntax for Deg: " input)))) )) (def: (log2 input) diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux index 0611e6e79..fe57508cc 100644 --- a/stdlib/source/lux/data/text.lux +++ b/stdlib/source/lux/data/text.lux @@ -20,7 +20,12 @@ (def: #export (contains? sub text) (-> Text Text Bool) - ("lux text contains?" text sub)) + (case ("lux text index" text sub +0) + (#;Some _) + true + + _ + false)) (do-template [ ] [(def: #export ( input) @@ -213,7 +218,7 @@ (def: #export (from-code code) (-> Nat Text) - ("lux nat to-char" code)) + ("lux nat char" code)) (def: #export (space? char) {#;doc "Checks whether the character is white-space."} diff --git a/stdlib/source/lux/lang/type.lux b/stdlib/source/lux/lang/type.lux index 974561605..d4a3d7d1b 100644 --- a/stdlib/source/lux/lang/type.lux +++ b/stdlib/source/lux/lang/type.lux @@ -30,7 +30,7 @@ ( env def) _ - type)) + ( (list/map (beta-reduce env) old-env) def))) ([#;UnivQ] [#;ExQ]) diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux index 917b7e094..0f2777ed8 100644 --- a/stdlib/source/lux/macro/syntax.lux +++ b/stdlib/source/lux/macro/syntax.lux @@ -228,15 +228,16 @@ (with-brackets (spaced (list/map constructor-arg$ constructor-args))) (with-brackets (spaced (list/map (method-def$ id) methods))))))] (wrap (list (` ((~ (code;text def-code)))))))))} - (let [[exported? tokens] (case tokens - (^ (list& [_ (#;Tag ["" "hidden"])] tokens')) - [(#;Some #;Left) tokens'] + (let [[exported? tokens] (: [(Maybe (Either Unit Unit)) (List Code)] + (case tokens + (^ (list& [_ (#;Tag ["" "hidden"])] tokens')) + [(#;Some #;Left) tokens'] - (^ (list& [_ (#;Tag ["" "export"])] tokens')) - [(#;Some #;Right) tokens'] + (^ (list& [_ (#;Tag ["" "export"])] tokens')) + [(#;Some #;Right) tokens'] - _ - [#;None tokens]) + _ + [#;None tokens])) ?parts (: (Maybe [Text (List Code) Code Code]) (case tokens (^ (list [_ (#;Form (list& [_ (#;Symbol ["" name])] args))] @@ -270,10 +271,10 @@ #let [g!state (code;symbol ["" "*compiler*"]) error-msg (code;text (text/compose "Wrong syntax for " name)) export-ast (: (List Code) (case exported? - (#;Some #E;Error) + (#;Some #;Left) (list (' #hidden)) - (#;Some #E;Success) + (#;Some #;Right) (list (' #export)) _ diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux index d1671537d..700bc9919 100644 --- a/stdlib/source/lux/math.lux +++ b/stdlib/source/lux/math.lux @@ -9,20 +9,17 @@ [code]))) ## [Values] -(do-template [ ] +(do-template [ ] [(def: #export + {#;doc } Frac - ())] + )] - [e "lux math e"] - [pi "lux math pi"] + [e 2.7182818284590452354 "The base of the natural logarithm."] + [pi 3.14159265358979323846 "The ratio of a circle's circumference to its diameter."] + [tau 6.28318530717958647692 "The ratio of a circle's circumference to its radius."] ) -(def: #export tau - {#;doc "The same as 2*PI."} - Frac - 6.28318530717958647692) - (do-template [ ] [(def: #export ( input) (-> Frac Frac) diff --git a/stdlib/source/lux/type/opaque.lux b/stdlib/source/lux/type/opaque.lux index 3b50fcbc2..636acd6e2 100644 --- a/stdlib/source/lux/type/opaque.lux +++ b/stdlib/source/lux/type/opaque.lux @@ -68,28 +68,30 @@ this-module (|> this-module (update@ #;defs (put down-cast (: Def [Macro macro-anns - (function [tokens] - (case tokens - (^ (list value)) - (wrap (list (` ((: (All [(~@ type-varsC)] - (-> (~ representation-declaration) (~ opaque-declaration))) - (|>. :!!)) - (~ value))))) - - _ - (macro;fail ($_ text/compose "Wrong syntax for " down-cast))))]))) + (: Macro + (function [tokens] + (case tokens + (^ (list value)) + (wrap (list (` ((: (All [(~@ type-varsC)] + (-> (~ representation-declaration) (~ opaque-declaration))) + (|>. :!!)) + (~ value))))) + + _ + (macro;fail ($_ text/compose "Wrong syntax for " down-cast)))))]))) (update@ #;defs (put up-cast (: Def [Macro macro-anns - (function [tokens] - (case tokens - (^ (list value)) - (wrap (list (` ((: (All [(~@ type-varsC)] - (-> (~ opaque-declaration) (~ representation-declaration))) - (|>. :!!)) - (~ value))))) - - _ - (macro;fail ($_ text/compose "Wrong syntax for " up-cast))))]))))]] + (: Macro + (function [tokens] + (case tokens + (^ (list value)) + (wrap (list (` ((: (All [(~@ type-varsC)] + (-> (~ opaque-declaration) (~ representation-declaration))) + (|>. :!!)) + (~ value))))) + + _ + (macro;fail ($_ text/compose "Wrong syntax for " up-cast)))))]))))]] (function [compiler] (#E;Success [(update@ #;modules (put this-module-name this-module) compiler) []])))) -- cgit v1.2.3