From b60d60ef6c0c70821991991fe716935e73038832 Mon Sep 17 00:00:00 2001
From: Eduardo Julian
Date: Wed, 22 Aug 2018 19:42:17 -0400
Subject: No more multi-line text.
---
stdlib/source/lux.lux | 769 +++++++++++++++++++++++++-------------------------
1 file changed, 383 insertions(+), 386 deletions(-)
(limited to 'stdlib/source/lux.lux')
diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 1114b069c..1b64aa22b 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -19,9 +19,9 @@
(1 [[dummy-cursor (7 ["lux" "export?"])]
[dummy-cursor (0 #1)]]
(1 [[dummy-cursor (7 ["lux" "doc"])]
- [dummy-cursor (5 "The type of things whose type is irrelevant.
-
- It can be used to write functions or data-structures that can take, or return, anything.")]]
+ [dummy-cursor (5 ("lux text concat"
+ "The type of things whose type is irrelevant.\n\n"
+ "It can be used to write functions or data-structures that can take, or return, anything."))]]
(0)))))])
## (type: Nothing
@@ -35,9 +35,9 @@
(1 [[dummy-cursor (7 ["lux" "export?"])]
[dummy-cursor (0 #1)]]
(1 [[dummy-cursor (7 ["lux" "doc"])]
- [dummy-cursor (5 "The type of things whose type is undefined.
-
- Useful for expressions that cause errors or other \"extraordinary\" conditions.")]]
+ [dummy-cursor (5 ("lux text concat"
+ "The type of things whose type is undefined.\n\n"
+ "Useful for expressions that cause errors or other \"extraordinary\" conditions."))]]
(0)))))])
## (type: (List a)
@@ -98,9 +98,9 @@
(#Cons [[dummy-cursor (7 ["lux" "export?"])]
[dummy-cursor (0 #1)]]
(#Cons [[dummy-cursor (7 ["lux" "doc"])]
- [dummy-cursor (5 "Natural numbers (unsigned integers).
-
- They start at zero (0) and extend in the positive direction.")]]
+ [dummy-cursor (5 ("lux text concat"
+ "Natural numbers (unsigned integers).\n\n"
+ "They start at zero (0) and extend in the positive direction."))]]
#Nil))))])
("lux def" Int
@@ -124,9 +124,9 @@
(#Cons [[dummy-cursor (7 ["lux" "export?"])]
[dummy-cursor (0 #1)]]
(#Cons [[dummy-cursor (7 ["lux" "doc"])]
- [dummy-cursor (5 "Fractional numbers that live in the interval [0,1).
-
- Useful for probability, and other domains that work within that interval.")]]
+ [dummy-cursor (5 ("lux text concat"
+ "Fractional numbers that live in the interval [0,1).\n\n"
+ "Useful for probability, and other domains that work within that interval."))]]
#Nil))))])
("lux def" Frac
@@ -162,9 +162,9 @@
(#Cons [[dummy-cursor (7 ["lux" "export?"])]
[dummy-cursor (0 #1)]]
(#Cons [[dummy-cursor (7 ["lux" "doc"])]
- [dummy-cursor (5 "A name.
-
- It is used as part of Lux syntax to represent identifiers and tags.")]]
+ [dummy-cursor (5 ("lux text concat"
+ "A name.\n\n"
+ "It is used as part of Lux syntax to represent identifiers and tags."))]]
#Nil))))])
## (type: (Maybe a)
@@ -747,11 +747,11 @@
(#Cons (text$ "host")
#Nil)))))))))))))]
(#Cons [(tag$ ["lux" "doc"])
- (text$ "Represents the state of the Lux compiler during a run.
-
- It is provided to macros during their invocation, so they can access compiler data.
-
- Caveat emptor: Avoid fiddling with it, unless you know what you're doing.")]
+ (text$ ("lux text concat"
+ "Represents the state of the Lux compiler during a run.\n\n"
+ ("lux text concat"
+ "It is provided to macros during their invocation, so they can access compiler data.\n\n"
+ "Caveat emptor: Avoid fiddling with it, unless you know what you're doing.")))]
default-def-meta-exported))))
## (type: (Meta a)
@@ -763,9 +763,9 @@
(#Apply (#Product Lux (#Parameter 1))
(#Apply Text Either)))))
(record$ (#Cons [(tag$ ["lux" "doc"])
- (text$ "Computations that can have access to the state of the compiler.
-
- These computations may fail, or modify the state of the compiler.")]
+ (text$ ("lux text concat"
+ "Computations that can have access to the state of the compiler.\n\n"
+ "These computations may fail, or modify the state of the compiler."))]
(#Cons [(tag$ ["lux" "type-args"])
(tuple$ (#Cons (text$ "a") #Nil))]
default-def-meta-exported))))
@@ -1027,9 +1027,11 @@
(macro:' #export (comment tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Throws away any code given to it.
- ## Great for commenting-out code, while retaining syntax high-lighting and formatting in your text editor.
- (comment +1 +2 +3 +4)")]
+ (text$ ("lux text concat"
+ "## Throws away any code given to it.\n\n"
+ ("lux text concat"
+ "## Great for commenting-out code, while retaining syntax high-lighting and formatting in your text editor.\n\n"
+ "(comment +1 +2 +3 +4)")))]
#Nil)
(return #Nil))
@@ -1219,14 +1221,13 @@
(macro:' #export (All tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Universal quantification.
- (All [a]
- (-> a a))
-
- ## A name can be provided, to specify a recursive type.
- (All List [a]
- (| Any
- [a (List a)]))")]
+ (text$ ("lux text concat"
+ "## Universal quantification.\n\n"
+ ("lux text concat"
+ "(All [a] (-> a a))\n\n"
+ ("lux text concat"
+ "## A name can be provided, to specify a recursive type.\n\n"
+ "(All List [a] (| Any [a (List a)]))"))))]
#Nil)
(let'' [self-name tokens] ({(#Cons [_ (#Identifier "" self-name)] tokens)
[self-name tokens]
@@ -1264,16 +1265,13 @@
(macro:' #export (Ex tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Existential quantification.
- (Ex [a]
- [(Codec Text a)
- a])
-
- ## A name can be provided, to specify a recursive type.
- (Ex Self [a]
- [(Codec Text a)
- a
- (List (Self a))])")]
+ (text$ ("lux text concat"
+ "## Existential quantification.\n\n"
+ ("lux text concat"
+ "(Ex [a] [(Codec Text a) a])\n\n"
+ ("lux text concat"
+ "## A name can be provided, to specify a recursive type.\n\n"
+ "(Ex Self [a] [(Codec Text a) a (List (Self a))])"))))]
#Nil)
(let'' [self-name tokens] ({(#Cons [_ (#Identifier "" self-name)] tokens)
[self-name tokens]
@@ -1319,10 +1317,11 @@
(macro:' #export (-> tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Function types:
- (-> Int Int Int)
-
- ## This is the type of a function that takes 2 Ints and returns an Int.")]
+ (text$ ("lux text concat"
+ "## Function types:\n\n"
+ ("lux text concat"
+ "(-> Int Int Int)\n\n"
+ "## This is the type of a function that takes 2 Ints and returns an Int.")))]
#Nil)
({(#Cons output inputs)
(return (#Cons (list/fold ("lux check" (#Function Code (#Function Code Code))
@@ -1337,8 +1336,9 @@
(macro:' #export (list xs)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## List-construction macro.
- (list +1 +2 +3)")]
+ (text$ ("lux text concat"
+ "## List-construction macro.\n\n"
+ "(list +1 +2 +3)"))]
#Nil)
(return (#Cons (list/fold (function'' [head tail]
(form$ (#Cons (tag$ ["lux" "Cons"])
@@ -1350,9 +1350,11 @@
(macro:' #export (list& xs)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## List-construction macro, with the last element being a tail-list.
- ## In other words, this macro prepends elements to another list.
- (list& +1 +2 +3 (list +4 +5 +6))")]
+ (text$ ("lux text concat"
+ "## List-construction macro, with the last element being a tail-list.\n\n"
+ ("lux text concat"
+ "## In other words, this macro prepends elements to another list.\n\n"
+ "(list& +1 +2 +3 (list +4 +5 +6))")))]
#Nil)
({(#Cons last init)
(return (list (list/fold (function'' [head tail]
@@ -1367,11 +1369,13 @@
(macro:' #export (& tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Tuple types:
- (& Text Int Bit)
-
- ## Any.
- (&)")]
+ (text$ ("lux text concat"
+ "## Tuple types:\n\n"
+ ("lux text concat"
+ "(& Text Int Bit)\n\n"
+ ("lux text concat"
+ "## Any.\n\n"
+ "(&)"))))]
#Nil)
({#Nil
(return (list (identifier$ ["lux" "Any"])))
@@ -1384,11 +1388,13 @@
(macro:' #export (| tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Variant types:
- (| Text Int Bit)
-
- ## Nothing.
- (|)")]
+ (text$ ("lux text concat"
+ "## Variant types:\n\n"
+ ("lux text concat"
+ "(| Text Int Bit)\n\n"
+ ("lux text concat"
+ "## Nothing.\n\n"
+ "(|)"))))]
#Nil)
({#Nil
(return (list (identifier$ ["lux" "Nothing"])))
@@ -1563,11 +1569,13 @@
(macro:' #export (_$ tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Left-association for the application of binary functions over variadic arguments.
- (_$ text/compose \"Hello, \" name \".\\nHow are you?\")
-
- ## =>
- (text/compose (text/compose \"Hello, \" name) \".\\nHow are you?\")")]
+ (text$ ("lux text concat"
+ "## Left-association for the application of binary functions over variadic arguments.\n\n"
+ ("lux text concat"
+ "(_$ text/compose \"Hello, \" name \".\\nHow are you?\")\n\n"
+ ("lux text concat"
+ "## =>\n\n"
+ "(text/compose (text/compose \"Hello, \" name) \".\\nHow are you?\")"))))]
#Nil)
({(#Cons op tokens')
({(#Cons first nexts)
@@ -1583,11 +1591,13 @@
(macro:' #export ($_ tokens)
(#Cons [(tag$ ["lux" "doc"])
- (text$ "## Right-association for the application of binary functions over variadic arguments.
- ($_ text/compose \"Hello, \" name \".\\nHow are you?\")
-
- ## =>
- (text/compose \"Hello, \" (text/compose name \".\\nHow are you?\"))")]
+ (text$ ("lux text concat"
+ "## Right-association for the application of binary functions over variadic arguments.\n\n"
+ ("lux text concat"
+ "($_ text/compose \"Hello, \" name \".\\nHow are you?\")\n\n"
+ ("lux text concat"
+ "## =>\n\n"
+ "(text/compose \"Hello, \" (text/compose name \".\\nHow are you?\"))"))))]
#Nil)
({(#Cons op tokens')
({(#Cons last prevs)
@@ -1715,13 +1725,10 @@
(macro:' #export (if tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "Picks which expression to evaluate based on a bit test value.
-
- (if #1
- \"Oh, yeah!\"
- \"Aw hell naw!\")
-
- => \"Oh, yeah!\"")])
+ (text$ ($_ "lux text concat"
+ "Picks which expression to evaluate based on a bit test value." "\n\n"
+ "(if #1 \"Oh, yeah!\" \"Aw hell naw!\")" "\n\n"
+ "=> \"Oh, yeah!\""))])
({(#Cons test (#Cons then (#Cons else #Nil)))
(return (list (form$ (list (record$ (list [(bit$ #1) then]
[(bit$ #0) else]))
@@ -1759,9 +1766,9 @@
(def:''' #export (log! message)
(list [(tag$ ["lux" "doc"])
- (text$ "Logs message to standard output.
-
- Useful for debugging.")])
+ (text$ ($_ "lux text concat"
+ "Logs message to standard output." "\n\n"
+ "Useful for debugging."))])
(-> Text Any)
("lux io log" message))
@@ -1966,10 +1973,10 @@
(macro:' #export (primitive tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Macro to treat define new primitive types.
- (primitive \"java.lang.Object\")
-
- (primitive \"java.util.List\" [(primitive \"java.lang.Long\")])")])
+ (text$ ($_ "lux text concat"
+ "## Macro to treat define new primitive types." "\n\n"
+ "(primitive \"java.lang.Object\")" "\n\n"
+ "(primitive \"java.util.List\" [(primitive \"java.lang.Long\")])"))])
({(#Cons [_ (#Text class-name)] #Nil)
(return (list (form$ (list (tag$ ["lux" "Primitive"]) (text$ class-name) (tag$ ["lux" "Nil"])))))
@@ -1997,11 +2004,10 @@
(macro:' #export (` tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Hygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~+) must also be used as forms.
- ## All unprefixed macros will receive their parent module's prefix if imported; otherwise will receive the prefix of the module on which the quasi-quote is being used.
- (` (def: (~ name)
- (function ((~' _) (~+ args))
- (~ body))))")])
+ (text$ ($_ "lux text concat"
+ "## Hygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~+) must also be used as forms." "\n\n"
+ "## All unprefixed macros will receive their parent module's prefix if imported; otherwise will receive the prefix of the module on which the quasi-quote is being used." "\n\n"
+ "(` (def: (~ name) (function ((~' _) (~+ args)) (~ body))))"))])
({(#Cons template #Nil)
(do Monad
[current-module current-module-name
@@ -2016,10 +2022,9 @@
(macro:' #export (`' tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Unhygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~+) must also be used as forms.
- (`' (def: (~ name)
- (function (_ (~+ args))
- (~ body))))")])
+ (text$ ($_ "lux text concat"
+ "## Unhygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~+) must also be used as forms." "\n\n"
+ "(`' (def: (~ name) (function (_ (~+ args)) (~ body))))"))])
({(#Cons template #Nil)
(do Monad
[=template (untemplate #1 "" template)]
@@ -2031,8 +2036,9 @@
(macro:' #export (' tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Quotation as a macro.
- (' \"YOLO\")")])
+ (text$ ($_ "lux text concat"
+ "## Quotation as a macro." "\n\n"
+ "(' \"YOLO\")"))])
({(#Cons template #Nil)
(do Monad
[=template (untemplate #0 "" template)]
@@ -2044,13 +2050,11 @@
(macro:' #export (|> tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Piping macro.
- (|> elems (list/map int/encode) (interpose \" \") (fold text/compose \"\"))
-
- ## =>
- (fold text/compose \"\"
- (interpose \" \"
- (list/map int/encode elems)))")])
+ (text$ ($_ "lux text concat"
+ "## Piping macro." "\n\n"
+ "(|> elems (list/map int/encode) (interpose \" \") (fold text/compose \"\"))" "\n\n"
+ "## =>" "\n\n"
+ "(fold text/compose \"\" (interpose \" \" (list/map int/encode elems)))"))])
({(#Cons [init apps])
(return (list (list/fold ("lux check" (-> Code Code Code)
(function' [app acc]
@@ -2072,13 +2076,11 @@
(macro:' #export (<| tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Reverse piping macro.
- (<| (fold text/compose \"\") (interpose \" \") (list/map int/encode) elems)
-
- ## =>
- (fold text/compose \"\"
- (interpose \" \"
- (list/map int/encode elems)))")])
+ (text$ ($_ "lux text concat"
+ "## Reverse piping macro." "\n\n"
+ "(<| (fold text/compose \"\") (interpose \" \") (list/map int/encode) elems)" "\n\n"
+ "## =>" "\n\n"
+ "(fold text/compose \"\" (interpose \" \" (list/map int/encode elems)))"))])
({(#Cons [init apps])
(return (list (list/fold ("lux check" (-> Code Code Code)
(function' [app acc]
@@ -2249,14 +2251,12 @@
(macro:' #export (do-template tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary.
- (do-template [ ]
- [(def: #export
- (-> Int Int)
- (i/+ ))]
-
- [inc +1]
- [dec -1])")])
+ (text$ ($_ "lux text concat"
+ "## By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary." "\n\n"
+ "(do-template [ ]" "\n"
+ " " "[(def: #export (-> Int Int) (i/+ ))]" "\n\n"
+ " " "[inc +1]" "\n"
+ " " "[dec -1]"))])
({(#Cons [[_ (#Tuple bindings)] (#Cons [[_ (#Tuple templates)] data])])
({[(#Some bindings') (#Some data')]
(let' [apply ("lux check" (-> RepEnv ($' List Code))
@@ -2602,11 +2602,10 @@
(def:''' #export (not x)
(list [(tag$ ["lux" "doc"])
- (text$ "## Bit negation.
-
- (not #1) => #0
-
- (not #0) => #1")])
+ (text$ ($_ "lux text concat"
+ "## Bit negation." "\n\n"
+ "(not #1) => #0" "\n\n"
+ "(not #0) => #1"))])
(-> Bit Bit)
(if x #0 #1))
@@ -2815,8 +2814,9 @@
(macro:' #export (type tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Takes a type expression and returns it's representation as data-structure.
- (type (All [a] (Maybe (List a))))")])
+ (text$ ($_ "lux text concat"
+ "## Takes a type expression and returns it's representation as data-structure." "\n\n"
+ "(type (All [a] (Maybe (List a))))"))])
({(#Cons type #Nil)
(do Monad
[type+ (macro-expand-all type)]
@@ -2833,8 +2833,9 @@
(macro:' #export (: tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## The type-annotation macro.
- (: (List Int) (list +1 +2 +3))")])
+ (text$ ($_ "lux text concat"
+ "## The type-annotation macro." "\n\n"
+ "(: (List Int) (list +1 +2 +3))"))])
({(#Cons type (#Cons value #Nil))
(return (list (` ("lux check" (type (~ type)) (~ value)))))
@@ -2844,8 +2845,9 @@
(macro:' #export (:coerce tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## The type-coercion macro.
- (:coerce Dinosaur (list +1 +2 +3))")])
+ (text$ ($_ "lux text concat"
+ "## The type-coercion macro." "\n\n"
+ "(:coerce Dinosaur (list +1 +2 +3))"))])
({(#Cons type (#Cons value #Nil))
(return (list (` ("lux coerce" (type (~ type)) (~ value)))))
@@ -2941,10 +2943,10 @@
(macro:' #export (Rec tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Parameter-less recursive types.
- ## A name has to be given to the whole type, to use it within its body.
- (Rec Self
- [Int (List Self)])")])
+ (text$ ($_ "lux text concat"
+ "## Parameter-less recursive types." "\n\n"
+ "## A name has to be given to the whole type, to use it within its body." "\n\n"
+ "(Rec Self [Int (List Self)])"))])
({(#Cons [_ (#Identifier "" name)] (#Cons body #Nil))
(let' [body' (replace-syntax (list [name (` (#.Apply (~ (make-parameter 1)) (~ (make-parameter 0))))])
(update-parameters body))]
@@ -2956,12 +2958,13 @@
(macro:' #export (exec tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Sequential execution of expressions (great for side-effects).
- (exec
- (log! \"#1\")
- (log! \"#2\")
- (log! \"#3\")
- \"YOLO\")")])
+ (text$ ($_ "lux text concat"
+ "## Sequential execution of expressions (great for side-effects)." "\n\n"
+ "(exec" "\n"
+ " " "(log! \"#1\")" "\n"
+ " " "(log! \"#2\")" "\n"
+ " " "(log! \"#3\")" "\n"
+ "\"YOLO\")"))])
({(#Cons value actions)
(let' [dummy (identifier$ ["" ""])]
(return (list (list/fold ("lux check" (-> Code Code Code)
@@ -3113,14 +3116,14 @@
(macro:' #export (case tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## The pattern-matching macro.
- ## Allows the usage of macros within the patterns to provide custom syntax.
- (case (: (List Int) (list +1 +2 +3))
- (#Cons x (#Cons y (#Cons z #Nil)))
- (#Some ($_ i/* x y z))
-
- _
- #None)")])
+ (text$ ($_ "lux text concat"
+ "## The pattern-matching macro." "\n"
+ "## Allows the usage of macros within the patterns to provide custom syntax." "\n"
+ "(case (: (List Int) (list +1 +2 +3))" "\n"
+ " " "(#Cons x (#Cons y (#Cons z #Nil)))" "\n"
+ " " "(#Some ($_ i/* x y z))" "\n\n"
+ " " "_" "\n"
+ " " "#None)"))])
({(#Cons value branches)
(do Monad
[expansion (expander branches)]
@@ -3132,14 +3135,15 @@
(macro:' #export (^ tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Macro-expanding patterns.
- ## It's a special macro meant to be used with 'case'.
- (case (: (List Int) (list +1 +2 +3))
- (^ (list x y z))
- (#Some ($_ i/* x y z))
-
- _
- #None)")])
+ (text$ ($_ "lux text concat"
+ "## Macro-expanding patterns." "\n"
+ "## It's a special macro meant to be used with 'case'." "\n"
+ "(case (: (List Int) (list +1 +2 +3))" "\n"
+ " (^ (list x y z))" "\n"
+ " (#Some ($_ i/* x y z))"
+ "\n\n"
+ " _" "\n"
+ " #None)"))])
(case tokens
(#Cons [_ (#Form (#Cons pattern #Nil))] (#Cons body branches))
(do Monad
@@ -3156,25 +3160,19 @@
(macro:' #export (^or tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Or-patterns.
- ## It's a special macro meant to be used with 'case'.
- (type: Weekday
- #Monday
- #Tuesday
- #Wednesday
- #Thursday
- #Friday
- #Saturday
- #Sunday)
-
- (def: (weekend? day)
- (-> Weekday Bit)
- (case day
- (^or #Saturday #Sunday)
- #1
-
- _
- #0))")])
+ (text$ ($_ "lux text concat"
+ "## Or-patterns." "\n"
+ "## It's a special macro meant to be used with 'case'." "\n"
+ "(type: Weekday #Monday #Tuesday #Wednesday #Thursday #Friday #Saturday #Sunday)"
+ "\n\n"
+ "(def: (weekend? day)" "\n"
+ " (-> Weekday Bit)" "\n"
+ " (case day" "\n"
+ " (^or #Saturday #Sunday)" "\n"
+ " #1"
+ "\n\n"
+ " _" "\n"
+ " #0))"))])
(case tokens
(^ (list& [_ (#Form patterns)] body branches))
(case patterns
@@ -3200,11 +3198,12 @@
(macro:' #export (let tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Creates local bindings.
- ## Can (optionally) use pattern-matching macros when binding.
- (let [x (foo bar)
- y (baz quux)]
- (op x y))")])
+ (text$ ($_ "lux text concat"
+ "## Creates local bindings." "\n"
+ "## Can (optionally) use pattern-matching macros when binding." "\n"
+ "(let [x (foo bar)" "\n"
+ " y (baz quux)]" "\n"
+ " (op x y))"))])
(case tokens
(^ (list [_ (#Tuple bindings)] body))
(if (multiple? 2 (list/size bindings))
@@ -3225,13 +3224,14 @@
(macro:' #export (function tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Syntax for creating functions.
- ## Allows for giving the function itself a name, for the sake of recursion.
- (: (All [a b] (-> a b a))
- (function (_ x y) x))
-
- (: (All [a b] (-> a b a))
- (function (const x y) x))")])
+ (text$ ($_ "lux text concat"
+ "## Syntax for creating functions." "\n"
+ "## Allows for giving the function itself a name, for the sake of recursion." "\n"
+ "(: (All [a b] (-> a b a))" "\n"
+ " (function (_ x y) x))"
+ "\n\n"
+ "(: (All [a b] (-> a b a))" "\n"
+ " (function (const x y) x))"))])
(case (: (Maybe [Text Code (List Code) Code])
(case tokens
(^ (list [_ (#Form (list& [_ (#Identifier ["" name])] head tail))] body))
@@ -3343,15 +3343,16 @@
(macro:' #export (def: tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "## Defines global constants/functions.
- (def: (rejoin-pair pair)
- (-> [Code Code] (List Code))
- (let [[left right] pair]
- (list left right)))
-
- (def: branching-exponent
- Int
- +5)")])
+ (text$ ($_ "lux text concat"
+ "## Defines global constants/functions." "\n"
+ "(def: (rejoin-pair pair)" "\n"
+ " (-> [Code Code] (List Code))" "\n"
+ " (let [[left right] pair]" "\n"
+ " (list left right)))"
+ "\n\n"
+ "(def: branching-exponent" "\n"
+ " Int" "\n"
+ " +5)"))])
(let [[export? tokens'] (export^ tokens)
parts (: (Maybe [Code (List Code) (Maybe Code) Code (List [Code Code])])
(case tokens'
@@ -3427,17 +3428,17 @@
(macro:' #export (macro: tokens)
(list [(tag$ ["lux" "doc"])
- (text$ "Macro-definition macro.
-
- (macro: #export (name-of tokens)
- (case tokens
- (^template []
- (^ (list [_ ( [prefix name])]))
- (return (list (` [(~ (text$ prefix)) (~ (text$ name))]))))
- ([#Identifier] [#Tag])
-
- _
- (fail \"Wrong syntax for name-of\")))")])
+ (text$ ($_ "lux text concat"
+ "## Macro-definition macro." "\n"
+ "(macro: #export (name-of tokens)" "\n"
+ " (case tokens" "\n"
+ " (^template []" "\n"
+ " (^ (list [_ ( [prefix name])]))" "\n"
+ " (return (list (` [(~ (text$ prefix)) (~ (text$ name))]))))" "\n"
+ " ([#Identifier] [#Tag])"
+ "\n\n"
+ " _" "\n"
+ " (fail \"Wrong syntax for name-of\")))"))])
(let [[exported? tokens] (export^ tokens)
name+args+meta+body?? (: (Maybe [Name (List Code) Code Code])
(case tokens
@@ -3474,18 +3475,19 @@
(fail "Wrong syntax for macro:"))))
(macro: #export (signature: tokens)
- {#.doc "## Definition of signatures ala ML.
- (signature: #export (Ord a)
- (: (Equivalence a)
- eq)
- (: (-> a a Bit)
- <)
- (: (-> a a Bit)
- <=)
- (: (-> a a Bit)
- >)
- (: (-> a a Bit)
- >=))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Definition of signatures ala ML." "\n"
+ "(signature: #export (Ord a)" "\n"
+ " (: (Equivalence a)" "\n"
+ " eq)" "\n"
+ " (: (-> a a Bit)" "\n"
+ " <)" "\n"
+ " (: (-> a a Bit)" "\n"
+ " <=)" "\n"
+ " (: (-> a a Bit)" "\n"
+ " >)" "\n"
+ " (: (-> a a Bit)" "\n"
+ " >=))"))}
(let [[exported? tokens'] (export^ tokens)
?parts (: (Maybe [Name (List Code) Code (List Code)])
(case tokens'
@@ -3600,17 +3602,20 @@
("lux text clip" text from to))
(def: #export (error! message)
- {#.doc "## Causes an error, with the given error message.
- (error! \"OH NO!\")"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Causes an error, with the given error message." "\n"
+ "(error! \"OH NO!\")"))}
(-> Text Nothing)
("lux io error" message))
(macro: (default tokens state)
- {#.doc "## Allows you to provide a default value that will be used
- ## if a (Maybe x) value turns out to be #.None.
- (default +20 (#.Some +10)) => +10
-
- (default +20 #.None) => +20"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Allows you to provide a default value that will be used" "\n"
+ "## if a (Maybe x) value turns out to be #.None."
+ "\n\n"
+ "(default +20 (#.Some +10)) ## => +10"
+ "\n\n"
+ "(default +20 #.None) ## => +20"))}
(case tokens
(^ (list else maybe))
(let [g!temp (: Code [dummy-cursor (#Identifier ["" ""])])
@@ -3883,19 +3888,20 @@
(|> parts list/reverse (list/fold text/compose "")))
(macro: #export (structure: tokens)
- {#.doc "## Definition of structures ala ML.
- (structure: #export Ord (Ord Int)
- (def: eq Equivalence)
- (def: (< test subject)
- (lux.< test subject))
- (def: (<= test subject)
- (or (lux.< test subject)
- (lux.= test subject)))
- (def: (lux.> test subject)
- (lux.> test subject))
- (def: (lux.>= test subject)
- (or (lux.> test subject)
- (lux.= test subject))))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Definition of structures ala ML." "\n"
+ "(structure: #export Ord (Ord Int)" "\n"
+ " (def: eq Equivalence)" "\n"
+ " (def: (< test subject)" "\n"
+ " (lux.i/< test subject))" "\n"
+ " (def: (<= test subject)" "\n"
+ " (or (lux.i/< test subject)" "\n"
+ " (lux.i/= test subject)))" "\n"
+ " (def: (> test subject)" "\n"
+ " (lux.i/> test subject))" "\n"
+ " (def: (>= test subject)" "\n"
+ " (or (lux.i/> test subject)" "\n"
+ " (lux.i/= test subject))))"))}
(let [[exported? tokens'] (export^ tokens)
?parts (: (Maybe [Code (List Code) Code Code (List Code)])
(case tokens'
@@ -3961,17 +3967,14 @@
(fail "Wrong syntax for structure:"))))
(def: #export (id x)
- {#.doc "Identity function.
-
- Does nothing to it's argument and just returns it."}
+ {#.doc "Identity function. Does nothing to it's argument and just returns it."}
(All [a] (-> a a))
x)
(macro: #export (type: tokens)
- {#.doc "## The type-definition macro.
- (type: (List a)
- #Nil
- (#Cons a (List a)))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## The type-definition macro." "\n"
+ "(type: (List a) #Nil (#Cons a (List a)))"))}
(let [[exported? tokens'] (export^ tokens)
[rec? tokens'] (case tokens'
(#Cons [_ (#Tag [_ "rec"])] tokens')
@@ -4202,7 +4205,7 @@
0 prefix
_ ($_ text/compose prefix "/" clean))]
(return output))
- (fail ($_ text/compose
+ (fail ($_ "lux text concat"
"Cannot climb the module hierarchy...\n"
"Importing module: " module "\n"
" Relative Root: " relative-root "\n"))))))
@@ -4488,11 +4491,12 @@
))
(macro: #export (^open tokens)
- {#.doc "## Same as the \"open\" macro, but meant to be used as a pattern-matching macro for generating local bindings.
- ## Takes an \"alias\" text for the generated local bindings.
- (def: #export (range (^open \".\") from to)
- (All [a] (-> (Enum a) a a (List a)))
- (range' <= succ from to))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Same as the \"open\" macro, but meant to be used as a pattern-matching macro for generating local bindings." "\n"
+ "## Takes an \"alias\" text for the generated local bindings." "\n"
+ "(def: #export (range (^open \".\") from to)" "\n"
+ " (All [a] (-> (Enum a) a a (List a)))" "\n"
+ " (range' <= succ from to))"))}
(case tokens
(^ (list& [_ (#Form (list [_ (#Text alias)]))] body branches))
(do Monad
@@ -4538,11 +4542,13 @@
(fail "Wrong syntax for ^open")))
(macro: #export (cond tokens)
- {#.doc "## Branching structures with multiple test conditions.
- (cond (n/even? num) \"even\"
- (n/odd? num) \"odd\"
- ## else-branch
- \"???\")"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Branching structures with multiple test conditions." "\n"
+ "(cond (n/even? num) \"even\"" "\n"
+ " (n/odd? num) \"odd\""
+ "\n\n"
+ " ## else-branch" "\n"
+ " \"???\")"))}
(if (n/= 0 (n/% 2 (list/size tokens)))
(fail "cond requires an uneven number of arguments.")
(case (list/reverse tokens)
@@ -4571,16 +4577,16 @@
(enumerate' 0 xs))
(macro: #export (get@ tokens)
- {#.doc "## Accesses the value of a record at a given tag.
- (get@ #field my-record)
-
- ## Can also work with multiple levels of nesting:
- (get@ [#foo #bar #baz] my-record)
-
- ## And, if only the slot/path is given, generates an
- ## accessor function:
- (let [getter (get@ [#foo #bar #baz])]
- (getter my-record))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Accesses the value of a record at a given tag." "\n"
+ "(get@ #field my-record)"
+ "\n\n"
+ "## Can also work with multiple levels of nesting:" "\n"
+ "(get@ [#foo #bar #baz] my-record)"
+ "\n\n"
+ "## And, if only the slot/path is given, generates an accessor function:" "\n"
+ "(let [getter (get@ [#foo #bar #baz])]" "\n"
+ " (getter my-record))"))}
(case tokens
(^ (list [_ (#Tag slot')] record))
(do Monad
@@ -4639,14 +4645,17 @@
[(~ cursor-code) (#.Record #Nil)])))))))
(macro: #export (open: tokens)
- {#.doc "## Opens a structure and generates a definition for each of its members (including nested members).
- ## For example:
- (open: \"i:.\" Number)
- ## Will generate:
- (def: i:+ (:: Number +))
- (def: i:- (:: Number -))
- (def: i:* (:: Number *))
- ..."}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Opens a structure and generates a definition for each of its members (including nested members)."
+ "\n\n"
+ "## For example:" "\n"
+ "(open: \"i:.\" Number)"
+ "\n\n"
+ "## Will generate:" "\n"
+ "(def: i:+ (:: Number +))" "\n"
+ "(def: i:- (:: Number -))" "\n"
+ "(def: i:* (:: Number *))" "\n"
+ "..."))}
(case tokens
(^ (list [_ (#Text alias)] struct))
(case struct
@@ -4678,26 +4687,22 @@
(fail "Wrong syntax for open:")))
(macro: #export (|>> tokens)
- {#.doc "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it.
- (|>> (list/map int/encode) (interpose \" \") (fold text/compose \"\"))
- ## =>
- (function (_ )
- (fold text/compose \"\"
- (interpose \" \"
- (list/map int/encode ))))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." "\n"
+ "(|>> (list/map int/encode) (interpose \" \") (fold text/compose \"\"))" "\n"
+ "## =>" "\n"
+ "(function (_ ) (fold text/compose \"\" (interpose \" \" (list/map int/encode ))))"))}
(do Monad
[g!_ (gensym "_")
g!arg (gensym "arg")]
(return (list (` (function ((~ g!_) (~ g!arg)) (|> (~ g!arg) (~+ tokens))))))))
(macro: #export (<<| tokens)
- {#.doc "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it.
- (<<| (fold text/compose \"\") (interpose \" \") (list/map int/encode))
- ## =>
- (function (_ )
- (fold text/compose \"\"
- (interpose \" \"
- (list/map int/encode ))))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." "\n"
+ "(<<| (fold text/compose \"\") (interpose \" \") (list/map int/encode))" "\n"
+ "## =>" "\n"
+ "(function (_ ) (fold text/compose \"\" (interpose \" \" (list/map int/encode ))))"))}
(do Monad
[g!_ (gensym "_")
g!arg (gensym "arg")]
@@ -4821,26 +4826,23 @@
(~+ openings)))))
(macro: #export (module: tokens)
- {#.doc "Module-definition macro.
-
- Can take optional annotations and allows the specification of modules to import.
-
- ## Examples
- (.module: {#.doc \"Some documentation...\"}
- [lux #*
- [control
- [\"M\" monad #*]]
- [data
- maybe
- [\".\" name (\"name/.\" Codec)]
- [\".\" text (\"text/.\" Monoid)]
- [collection
- [list (\"list/.\" Monad)]]]
- meta
- [macro
- code]]
- [//
- [type (\".\" Equivalence)]])"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Module-definition macro."
+ "\n\n"
+ "## Can take optional annotations and allows the specification of modules to import."
+ "\n\n"
+ "## Example" "\n"
+ "(.module: {#.doc \"Some documentation...\"}" "\n"
+ " [lux #*" "\n"
+ " [control" "\n"
+ " [\"M\" monad #*]]" "\n"
+ " [data" "\n"
+ " maybe" "\n"
+ " [\".\" name (\"name/.\" Codec)]]" "\n"
+ " [macro" "\n"
+ " code]]" "\n"
+ " [//" "\n"
+ " [type (\".\" Equivalence)]])"))}
(do Monad
[#let [[_meta _imports] (: [(List [Code Code]) (List Code)]
(case tokens
@@ -4866,11 +4868,12 @@
(wrap (#Cons =module =refers))))
(macro: #export (:: tokens)
- {#.doc "## Allows accessing the value of a structure's member.
- (:: Codec encode)
-
- ## Also allows using that value as a function.
- (:: Codec encode +123)"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Allows accessing the value of a structure's member." "\n"
+ "(:: Codec encode)"
+ "\n\n"
+ "## Also allows using that value as a function." "\n"
+ "(:: Codec encode +123)"))}
(case tokens
(^ (list struct [_ (#Identifier member)]))
(return (list (` (let [(^open ".") (~ struct)] (~ (identifier$ member))))))
@@ -4882,19 +4885,16 @@
(fail "Wrong syntax for ::")))
(macro: #export (set@ tokens)
- {#.doc "## Sets the value of a record at a given tag.
- (set@ #name \"Lux\" lang)
-
- ## Can also work with multiple levels of nesting:
- (set@ [#foo #bar #baz] value my-record)
-
- ## And, if only the slot/path and (optionally) the value are given, generates a
- ## mutator function:
- (let [setter (set@ [#foo #bar #baz] value)]
- (setter my-record))
-
- (let [setter (set@ [#foo #bar #baz])]
- (setter value my-record))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Sets the value of a record at a given tag." "\n"
+ "(set@ #name \"Lux\" lang)"
+ "\n\n"
+ "## Can also work with multiple levels of nesting:" "\n"
+ "(set@ [#foo #bar #baz] value my-record)"
+ "\n\n"
+ "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" "\n"
+ "(let [setter (set@ [#foo #bar #baz] value)] (setter my-record))" "\n"
+ "(let [setter (set@ [#foo #bar #baz])] (setter value my-record))"))}
(case tokens
(^ (list [_ (#Tag slot')] value record))
(do Monad
@@ -4972,19 +4972,16 @@
(fail "Wrong syntax for set@")))
(macro: #export (update@ tokens)
- {#.doc "## Modifies the value of a record at a given tag, based on some function.
- (update@ #age inc person)
-
- ## Can also work with multiple levels of nesting:
- (update@ [#foo #bar #baz] func my-record)
-
- ## And, if only the slot/path and (optionally) the value are given, generates a
- ## mutator function:
- (let [updater (update@ [#foo #bar #baz] func)]
- (updater my-record))
-
- (let [updater (update@ [#foo #bar #baz])]
- (updater func my-record))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Modifies the value of a record at a given tag, based on some function." "\n"
+ "(update@ #age inc person)"
+ "\n\n"
+ "## Can also work with multiple levels of nesting:" "\n"
+ "(update@ [#foo #bar #baz] func my-record)"
+ "\n\n"
+ "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" "\n"
+ "(let [updater (update@ [#foo #bar #baz] func)] (updater my-record))" "\n"
+ "(let [updater (update@ [#foo #bar #baz])] (updater func my-record))"))}
(case tokens
(^ (list [_ (#Tag slot')] fun record))
(do Monad
@@ -5048,41 +5045,40 @@
(fail "Wrong syntax for update@")))
(macro: #export (^template tokens)
- {#.doc "## It's similar to do-template, but meant to be used during pattern-matching.
- (def: (beta-reduce env type)
- (-> (List Type) Type Type)
- (case type
- (#.Primitive name params)
- (#.Primitive name (list/map (beta-reduce env) params))
-
- (^template []
- ( left right)
- ( (beta-reduce env left) (beta-reduce env right)))
- ([#.Sum] [#.Product])
-
- (^template []
- ( left right)
- ( (beta-reduce env left) (beta-reduce env right)))
- ([#.Function]
- [#.Apply])
-
- (^template []
- ( old-env def)
- (case old-env
- #.Nil
- ( env def)
-
- _
- type))
- ([#.UnivQ]
- [#.ExQ])
-
- (#.Parameter idx)
- (default type (list.nth idx env))
-
- _
- type
- ))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## It's similar to do-template, but meant to be used during pattern-matching." "\n"
+ "(def: (beta-reduce env type)" "\n"
+ " (-> (List Type) Type Type)" "\n"
+ " (case type" "\n"
+ " (#.Primitive name params)" "\n"
+ " (#.Primitive name (list/map (beta-reduce env) params))"
+ "\n\n"
+ " (^template []" "\n"
+ " ( left right)" "\n"
+ " ( (beta-reduce env left) (beta-reduce env right)))" "\n"
+ " ([#.Sum] [#.Product])"
+ "\n\n"
+ " (^template []" "\n"
+ " ( left right)" "\n"
+ " ( (beta-reduce env left) (beta-reduce env right)))" "\n"
+ " ([#.Function] [#.Apply])"
+ "\n\n"
+ " (^template []" "\n"
+ " ( old-env def)" "\n"
+ " (case old-env" "\n"
+ " #.Nil" "\n"
+ " ( env def)"
+ "\n\n"
+ " _" "\n"
+ " type))" "\n"
+ " ([#.UnivQ] [#.ExQ])"
+ "\n\n"
+ " (#.Parameter idx)" "\n"
+ " (default type (list.nth idx env))"
+ "\n\n"
+ " _" "\n"
+ " type" "\n"
+ " ))"))}
(case tokens
(^ (list& [_ (#Form (list& [_ (#Tuple bindings)] templates))]
[_ (#Form data)]
@@ -5282,16 +5278,17 @@
(text/compose text "\n\n"))))
(macro: #export (doc tokens)
- {#.doc "## Creates code documentation, embedding text as comments and properly formatting the forms it's being given.
-
- ## For Example:
- (doc \"Allows arbitrary looping, using the \\\"recur\\\" form to re-start the loop.
- Can be used in monadic code to create monadic loops.\"
- (loop [count +0
- x init]
- (if (< +10 count)
- (recur (inc count) (f x))
- x)))"}
+ {#.doc (text$ ($_ "lux text concat"
+ "## Creates code documentation, embedding text as comments and properly formatting the forms it's being given."
+ "\n\n"
+ "## For Example:" "\n"
+ "(doc \"Allows arbitrary looping, using the \\\"recur\\\" form to re-start the loop.\"" "\n"
+ " \"Can be used in monadic code to create monadic loops.\"" "\n"
+ " (loop [count +0" "\n"
+ " x init]" "\n"
+ " (if (< +10 count)" "\n"
+ " (recur (inc count) (f x))" "\n"
+ " x)))"))}
(return (list (` [(~ cursor-code)
(#.Text (~ (|> tokens
(list/map (|>> identify-doc-fragment doc-fragment->Text))
--
cgit v1.2.3