From bc251026c21590da76085bc0bc9abeaa5ec242b6 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Thu, 23 Aug 2018 00:56:59 -0400 Subject: No more escaping of new-line. --- stdlib/source/lux.lux | 496 +++++++++++++++++++++++++------------------------- 1 file changed, 252 insertions(+), 244 deletions(-) (limited to 'stdlib/source/lux.lux') diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux index 5e14a9806..0417c9a4d 100644 --- a/stdlib/source/lux.lux +++ b/stdlib/source/lux.lux @@ -3,6 +3,16 @@ ("lux int char" +34)) [["" 0 0] (10 (0))]) +("lux def" new-line + ("lux check" (0 "#Text" (0)) + ("lux int char" +10)) + [["" 0 0] (10 (0))]) + +("lux def" __paragraph + ("lux check" (0 "#Text" (0)) + ("lux text concat" new-line new-line)) + [["" 0 0] (10 (0))]) + ("lux def" dummy-cursor ("lux check" (2 (0 "#Text" (0)) (2 (0 "#I64" (1 (0 "#Nat" (0)) (0))) @@ -25,7 +35,7 @@ [dummy-cursor (0 #1)]] (1 [[dummy-cursor (7 ["lux" "doc"])] [dummy-cursor (5 ("lux text concat" - "The type of things whose type is irrelevant.\n\n" + ("lux text concat" "The type of things whose type is irrelevant." __paragraph) "It can be used to write functions or data-structures that can take, or return, anything."))]] (0)))))]) @@ -41,7 +51,7 @@ [dummy-cursor (0 #1)]] (1 [[dummy-cursor (7 ["lux" "doc"])] [dummy-cursor (5 ("lux text concat" - "The type of things whose type is undefined.\n\n" + ("lux text concat" "The type of things whose type is undefined." __paragraph) "Useful for expressions that cause errors or other 'extraordinary' conditions."))]] (0)))))]) @@ -104,7 +114,7 @@ [dummy-cursor (0 #1)]] (#Cons [[dummy-cursor (7 ["lux" "doc"])] [dummy-cursor (5 ("lux text concat" - "Natural numbers (unsigned integers).\n\n" + ("lux text concat" "Natural numbers (unsigned integers)." __paragraph) "They start at zero (0) and extend in the positive direction."))]] #Nil))))]) @@ -130,7 +140,7 @@ [dummy-cursor (0 #1)]] (#Cons [[dummy-cursor (7 ["lux" "doc"])] [dummy-cursor (5 ("lux text concat" - "Fractional numbers that live in the interval [0,1).\n\n" + ("lux text concat" "Fractional numbers that live in the interval [0,1)." __paragraph) "Useful for probability, and other domains that work within that interval."))]] #Nil))))]) @@ -167,9 +177,7 @@ (#Cons [[dummy-cursor (7 ["lux" "export?"])] [dummy-cursor (0 #1)]] (#Cons [[dummy-cursor (7 ["lux" "doc"])] - [dummy-cursor (5 ("lux text concat" - "A name.\n\n" - "It is used as part of Lux syntax to represent identifiers and tags."))]] + [dummy-cursor (5 "A name. It is used as part of Lux syntax to represent identifiers and tags.")]] #Nil))))]) ## (type: (Maybe a) @@ -753,9 +761,9 @@ #Nil)))))))))))))] (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "Represents the state of the Lux compiler during a run.\n\n" + ("lux text concat" "Represents the state of the Lux compiler during a run." __paragraph) ("lux text concat" - "It is provided to macros during their invocation, so they can access compiler data.\n\n" + ("lux text concat" "It is provided to macros during their invocation, so they can access compiler data." __paragraph) "Caveat emptor: Avoid fiddling with it, unless you know what you're doing.")))] default-def-meta-exported)))) @@ -769,7 +777,7 @@ (#Apply Text Either))))) (record$ (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "Computations that can have access to the state of the compiler.\n\n" + ("lux text concat" "Computations that can have access to the state of the compiler." __paragraph) "These computations may fail, or modify the state of the compiler."))] (#Cons [(tag$ ["lux" "type-args"]) (tuple$ (#Cons (text$ "a") #Nil))] @@ -1033,9 +1041,9 @@ (macro:' #export (comment tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Throws away any code given to it.\n\n" + ("lux text concat" "## Throws away any code given to it." __paragraph) ("lux text concat" - "## Great for commenting-out code, while retaining syntax high-lighting and formatting in your text editor.\n\n" + ("lux text concat" "## Great for commenting-out code, while retaining syntax high-lighting and formatting in your text editor." __paragraph) "(comment +1 +2 +3 +4)")))] #Nil) (return #Nil)) @@ -1227,11 +1235,11 @@ (macro:' #export (All tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Universal quantification.\n\n" + ("lux text concat" "## Universal quantification." __paragraph) ("lux text concat" - "(All [a] (-> a a))\n\n" + ("lux text concat" "(All [a] (-> a a))" __paragraph) ("lux text concat" - "## A name can be provided, to specify a recursive type.\n\n" + ("lux text concat" "## A name can be provided, to specify a recursive type." __paragraph) "(All List [a] (| Any [a (List a)]))"))))] #Nil) (let'' [self-name tokens] ({(#Cons [_ (#Identifier "" self-name)] tokens) @@ -1271,11 +1279,11 @@ (macro:' #export (Ex tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Existential quantification.\n\n" + ("lux text concat" "## Existential quantification." __paragraph) ("lux text concat" - "(Ex [a] [(Codec Text a) a])\n\n" + ("lux text concat" "(Ex [a] [(Codec Text a) a])" __paragraph) ("lux text concat" - "## A name can be provided, to specify a recursive type.\n\n" + ("lux text concat" "## A name can be provided, to specify a recursive type." __paragraph) "(Ex Self [a] [(Codec Text a) a (List (Self a))])"))))] #Nil) (let'' [self-name tokens] ({(#Cons [_ (#Identifier "" self-name)] tokens) @@ -1323,9 +1331,9 @@ (macro:' #export (-> tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Function types:\n\n" + ("lux text concat" "## Function types:" __paragraph) ("lux text concat" - "(-> Int Int Int)\n\n" + ("lux text concat" "(-> Int Int Int)" __paragraph) "## This is the type of a function that takes 2 Ints and returns an Int.")))] #Nil) ({(#Cons output inputs) @@ -1342,7 +1350,7 @@ (macro:' #export (list xs) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## List-construction macro.\n\n" + ("lux text concat" "## List-construction macro." __paragraph) "(list +1 +2 +3)"))] #Nil) (return (#Cons (list/fold (function'' [head tail] @@ -1356,9 +1364,9 @@ (macro:' #export (list& xs) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## List-construction macro, with the last element being a tail-list.\n\n" + ("lux text concat" "## List-construction macro, with the last element being a tail-list." __paragraph) ("lux text concat" - "## In other words, this macro prepends elements to another list.\n\n" + ("lux text concat" "## In other words, this macro prepends elements to another list." __paragraph) "(list& +1 +2 +3 (list +4 +5 +6))")))] #Nil) ({(#Cons last init) @@ -1375,11 +1383,11 @@ (macro:' #export (& tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Tuple types:\n\n" + ("lux text concat" "## Tuple types:" __paragraph) ("lux text concat" - "(& Text Int Bit)\n\n" + ("lux text concat" "(& Text Int Bit)" __paragraph) ("lux text concat" - "## Any.\n\n" + ("lux text concat" "## Any." __paragraph) "(&)"))))] #Nil) ({#Nil @@ -1394,11 +1402,11 @@ (macro:' #export (| tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Variant types:\n\n" + ("lux text concat" "## Variant types:" __paragraph) ("lux text concat" - "(| Text Int Bit)\n\n" + ("lux text concat" "(| Text Int Bit)" __paragraph) ("lux text concat" - "## Nothing.\n\n" + ("lux text concat" "## Nothing." __paragraph) "(|)"))))] #Nil) ({#Nil @@ -1575,12 +1583,12 @@ (macro:' #export (_$ tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Left-association for the application of binary functions over variadic arguments.\n\n" + ("lux text concat" "## Left-association for the application of binary functions over variadic arguments." ..new-line) ("lux text concat" - "(_$ text/compose ''Hello, '' name ''.\\nHow are you?'')\n\n" + ("lux text concat" "(_$ text/compose ''Hello, '' name ''. How are you?'')" ..new-line) ("lux text concat" - "## =>\n\n" - "(text/compose (text/compose ''Hello, '' name) ''.\\nHow are you?'')"))))] + ("lux text concat" "## =>" ..new-line) + "(text/compose (text/compose ''Hello, '' name) ''. How are you?'')"))))] #Nil) ({(#Cons op tokens') ({(#Cons first nexts) @@ -1597,12 +1605,12 @@ (macro:' #export ($_ tokens) (#Cons [(tag$ ["lux" "doc"]) (text$ ("lux text concat" - "## Right-association for the application of binary functions over variadic arguments.\n\n" + ("lux text concat" "## Right-association for the application of binary functions over variadic arguments." ..new-line) ("lux text concat" - "($_ text/compose ''Hello, '' name ''.\\nHow are you?'')\n\n" + ("lux text concat" "($_ text/compose ''Hello, '' name ''. How are you?'')" ..new-line) ("lux text concat" - "## =>\n\n" - "(text/compose ''Hello, '' (text/compose name ''.\\nHow are you?''))"))))] + ("lux text concat" "## =>" ..new-line) + "(text/compose ''Hello, '' (text/compose name ''. How are you?''))"))))] #Nil) ({(#Cons op tokens') ({(#Cons last prevs) @@ -1731,8 +1739,8 @@ (macro:' #export (if tokens) (list [(tag$ ["lux" "doc"]) (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" + "Picks which expression to evaluate based on a bit test value." __paragraph + "(if #1 ''Oh, yeah!'' ''Aw hell naw!'')" __paragraph "=> ''Oh, yeah!''"))]) ({(#Cons test (#Cons then (#Cons else #Nil))) (return (list (form$ (list (record$ (list [(bit$ #1) then] @@ -1772,7 +1780,7 @@ (def:''' #export (log! message) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "Logs message to standard output." "\n\n" + "Logs message to standard output." __paragraph "Useful for debugging."))]) (-> Text Any) ("lux io log" message)) @@ -1979,8 +1987,8 @@ (macro:' #export (primitive tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Macro to treat define new primitive types." "\n\n" - "(primitive ''java.lang.Object'')" "\n\n" + "## Macro to treat define new primitive types." __paragraph + "(primitive ''java.lang.Object'')" __paragraph "(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"]))))) @@ -2010,8 +2018,8 @@ (macro:' #export (` tokens) (list [(tag$ ["lux" "doc"]) (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" + "## Hygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~+) must also be used as forms." __paragraph + "## 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." __paragraph "(` (def: (~ name) (function ((~' _) (~+ args)) (~ body))))"))]) ({(#Cons template #Nil) (do Monad @@ -2028,7 +2036,7 @@ (macro:' #export (`' tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Unhygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~+) must also be used as forms." "\n\n" + "## Unhygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~+) must also be used as forms." __paragraph "(`' (def: (~ name) (function (_ (~+ args)) (~ body))))"))]) ({(#Cons template #Nil) (do Monad @@ -2042,7 +2050,7 @@ (macro:' #export (' tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Quotation as a macro." "\n\n" + "## Quotation as a macro." __paragraph "(' YOLO)"))]) ({(#Cons template #Nil) (do Monad @@ -2056,9 +2064,9 @@ (macro:' #export (|> tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Piping macro." "\n\n" - "(|> elems (list/map int/encode) (interpose '' '') (fold text/compose ''''))" "\n\n" - "## =>" "\n\n" + "## Piping macro." __paragraph + "(|> elems (list/map int/encode) (interpose '' '') (fold text/compose ''''))" __paragraph + "## =>" __paragraph "(fold text/compose '''' (interpose '' '' (list/map int/encode elems)))"))]) ({(#Cons [init apps]) (return (list (list/fold ("lux check" (-> Code Code Code) @@ -2082,9 +2090,9 @@ (macro:' #export (<| tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Reverse piping macro." "\n\n" - "(<| (fold text/compose '''') (interpose '' '') (list/map int/encode) elems)" "\n\n" - "## =>" "\n\n" + "## Reverse piping macro." __paragraph + "(<| (fold text/compose '''') (interpose '' '') (list/map int/encode) elems)" __paragraph + "## =>" __paragraph "(fold text/compose '''' (interpose '' '' (list/map int/encode elems)))"))]) ({(#Cons [init apps]) (return (list (list/fold ("lux check" (-> Code Code Code) @@ -2257,10 +2265,10 @@ (macro:' #export (do-template tokens) (list [(tag$ ["lux" "doc"]) (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" + "## By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary." __paragraph + "(do-template [ ]" ..new-line + " " "[(def: #export (-> Int Int) (i/+ ))]" __paragraph + " " "[inc +1]" ..new-line " " "[dec -1]"))]) ({(#Cons [[_ (#Tuple bindings)] (#Cons [[_ (#Tuple templates)] data])]) ({[(#Some bindings') (#Some data')] @@ -2608,8 +2616,8 @@ (def:''' #export (not x) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Bit negation." "\n\n" - "(not #1) => #0" "\n\n" + "## Bit negation." __paragraph + "(not #1) => #0" __paragraph "(not #0) => #1"))]) (-> Bit Bit) (if x #0 #1)) @@ -2820,7 +2828,7 @@ (macro:' #export (type tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Takes a type expression and returns it's representation as data-structure." "\n\n" + "## Takes a type expression and returns it's representation as data-structure." __paragraph "(type (All [a] (Maybe (List a))))"))]) ({(#Cons type #Nil) (do Monad @@ -2839,7 +2847,7 @@ (macro:' #export (: tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## The type-annotation macro." "\n\n" + "## The type-annotation macro." __paragraph "(: (List Int) (list +1 +2 +3))"))]) ({(#Cons type (#Cons value #Nil)) (return (list (` ("lux check" (type (~ type)) (~ value))))) @@ -2851,7 +2859,7 @@ (macro:' #export (:coerce tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## The type-coercion macro." "\n\n" + "## The type-coercion macro." __paragraph "(:coerce Dinosaur (list +1 +2 +3))"))]) ({(#Cons type (#Cons value #Nil)) (return (list (` ("lux coerce" (type (~ type)) (~ value))))) @@ -2949,8 +2957,8 @@ (macro:' #export (Rec tokens) (list [(tag$ ["lux" "doc"]) (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" + "## Parameter-less recursive types." __paragraph + "## A name has to be given to the whole type, to use it within its body." __paragraph "(Rec Self [Int (List Self)])"))]) ({(#Cons [_ (#Identifier "" name)] (#Cons body #Nil)) (let' [body' (replace-syntax (list [name (` (#.Apply (~ (make-parameter 1)) (~ (make-parameter 0))))]) @@ -2964,11 +2972,11 @@ (macro:' #export (exec tokens) (list [(tag$ ["lux" "doc"]) (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" + "## Sequential execution of expressions (great for side-effects)." __paragraph + "(exec" ..new-line + " " "(log! ''#1'')" ..new-line + " " "(log! ''#2'')" ..new-line + " " "(log! ''#3'')" ..new-line "''YOLO'')"))]) ({(#Cons value actions) (let' [dummy (identifier$ ["" ""])] @@ -3122,12 +3130,12 @@ (macro:' #export (case tokens) (list [(tag$ ["lux" "doc"]) (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" + "## The pattern-matching macro." ..new-line + "## Allows the usage of macros within the patterns to provide custom syntax." ..new-line + "(case (: (List Int) (list +1 +2 +3))" ..new-line + " " "(#Cons x (#Cons y (#Cons z #Nil)))" ..new-line + " " "(#Some ($_ i/* x y z))" __paragraph + " " "_" ..new-line " " "#None)"))]) ({(#Cons value branches) (do Monad @@ -3141,13 +3149,13 @@ (macro:' #export (^ tokens) (list [(tag$ ["lux" "doc"]) (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" + "## Macro-expanding patterns." ..new-line + "## It's a special macro meant to be used with 'case'." ..new-line + "(case (: (List Int) (list +1 +2 +3))" ..new-line + " (^ (list x y z))" ..new-line " (#Some ($_ i/* x y z))" - "\n\n" - " _" "\n" + __paragraph + " _" ..new-line " #None)"))]) (case tokens (#Cons [_ (#Form (#Cons pattern #Nil))] (#Cons body branches)) @@ -3166,17 +3174,17 @@ (macro:' #export (^or tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Or-patterns." "\n" - "## It's a special macro meant to be used with 'case'." "\n" + "## Or-patterns." ..new-line + "## It's a special macro meant to be used with 'case'." ..new-line "(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" + __paragraph + "(def: (weekend? day)" ..new-line + " (-> Weekday Bit)" ..new-line + " (case day" ..new-line + " (^or #Saturday #Sunday)" ..new-line " #1" - "\n\n" - " _" "\n" + __paragraph + " _" ..new-line " #0))"))]) (case tokens (^ (list& [_ (#Form patterns)] body branches)) @@ -3204,10 +3212,10 @@ (macro:' #export (let tokens) (list [(tag$ ["lux" "doc"]) (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" + "## Creates local bindings." ..new-line + "## Can (optionally) use pattern-matching macros when binding." ..new-line + "(let [x (foo bar)" ..new-line + " y (baz quux)]" ..new-line " (op x y))"))]) (case tokens (^ (list [_ (#Tuple bindings)] body)) @@ -3230,12 +3238,12 @@ (macro:' #export (function tokens) (list [(tag$ ["lux" "doc"]) (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" + "## Syntax for creating functions." ..new-line + "## Allows for giving the function itself a name, for the sake of recursion." ..new-line + "(: (All [a b] (-> a b a))" ..new-line " (function (_ x y) x))" - "\n\n" - "(: (All [a b] (-> a b a))" "\n" + __paragraph + "(: (All [a b] (-> a b a))" ..new-line " (function (const x y) x))"))]) (case (: (Maybe [Text Code (List Code) Code]) (case tokens @@ -3349,14 +3357,14 @@ (macro:' #export (def: tokens) (list [(tag$ ["lux" "doc"]) (text$ ($_ "lux text concat" - "## Defines global constants/functions." "\n" - "(def: (rejoin-pair pair)" "\n" - " (-> [Code Code] (List Code))" "\n" - " (let [[left right] pair]" "\n" + "## Defines global constants/functions." ..new-line + "(def: (rejoin-pair pair)" ..new-line + " (-> [Code Code] (List Code))" ..new-line + " (let [[left right] pair]" ..new-line " (list left right)))" - "\n\n" - "(def: branching-exponent" "\n" - " Int" "\n" + __paragraph + "(def: branching-exponent" ..new-line + " Int" ..new-line " +5)"))]) (let [[export? tokens'] (export^ tokens) parts (: (Maybe [Code (List Code) (Maybe Code) Code (List [Code Code])]) @@ -3434,15 +3442,15 @@ (macro:' #export (macro: tokens) (list [(tag$ ["lux" "doc"]) (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" + "## Macro-definition macro." ..new-line + "(macro: #export (name-of tokens)" ..new-line + " (case tokens" ..new-line + " (^template []" ..new-line + " (^ (list [_ ( [prefix name])]))" ..new-line + " (return (list (` [(~ (text$ prefix)) (~ (text$ name))]))))" ..new-line " ([#Identifier] [#Tag])" - "\n\n" - " _" "\n" + __paragraph + " _" ..new-line " (fail ''Wrong syntax for name-of'')))"))]) (let [[exported? tokens] (export^ tokens) name+args+meta+body?? (: (Maybe [Name (List Code) Code Code]) @@ -3481,17 +3489,17 @@ (macro: #export (signature: tokens) {#.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" + "## Definition of signatures ala ML." ..new-line + "(signature: #export (Ord a)" ..new-line + " (: (Equivalence a)" ..new-line + " eq)" ..new-line + " (: (-> a a Bit)" ..new-line + " <)" ..new-line + " (: (-> a a Bit)" ..new-line + " <=)" ..new-line + " (: (-> a a Bit)" ..new-line + " >)" ..new-line + " (: (-> a a Bit)" ..new-line " >=))"))} (let [[exported? tokens'] (export^ tokens) ?parts (: (Maybe [Name (List Code) Code (List Code)]) @@ -3573,8 +3581,8 @@ _ (fail )))] - [and (if (~ pre) (~ post) #0) "'and' requires >=1 clauses." "Short-circuiting 'and'.\n(and #1 #0 #1) ## => #0"] - [or (if (~ pre) #1 (~ post)) "'or' requires >=1 clauses." "Short-circuiting 'or'.\n(or #1 #0 #1) ## => #1"]) + [and (if (~ pre) (~ post) #0) "'and' requires >=1 clauses." "Short-circuiting 'and': (and #1 #0 #1) ## => #0"] + [or (if (~ pre) #1 (~ post)) "'or' requires >=1 clauses." "Short-circuiting 'or': (or #1 #0 #1) ## => #1"]) (def: (index-of part text) (-> Text Text (Maybe Nat)) @@ -3608,18 +3616,18 @@ (def: #export (error! message) {#.doc (text$ ($_ "lux text concat" - "## Causes an error, with the given error message." "\n" + "## Causes an error, with the given error message." ..new-line "(error! ''OH NO!'')"))} (-> Text Nothing) ("lux io error" message)) (macro: (default tokens state) {#.doc (text$ ($_ "lux text concat" - "## Allows you to provide a default value that will be used" "\n" + "## Allows you to provide a default value that will be used" ..new-line "## if a (Maybe x) value turns out to be #.None." - "\n\n" + __paragraph "(default +20 (#.Some +10)) ## => +10" - "\n\n" + __paragraph "(default +20 #.None) ## => +20"))} (case tokens (^ (list else maybe)) @@ -3894,18 +3902,18 @@ (macro: #export (structure: tokens) {#.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" + "## Definition of structures ala ML." ..new-line + "(structure: #export Ord (Ord Int)" ..new-line + " (def: eq Equivalence)" ..new-line + " (def: (< test subject)" ..new-line + " (lux.i/< test subject))" ..new-line + " (def: (<= test subject)" ..new-line + " (or (lux.i/< test subject)" ..new-line + " (lux.i/= test subject)))" ..new-line + " (def: (> test subject)" ..new-line + " (lux.i/> test subject))" ..new-line + " (def: (>= test subject)" ..new-line + " (or (lux.i/> test subject)" ..new-line " (lux.i/= test subject))))"))} (let [[exported? tokens'] (export^ tokens) ?parts (: (Maybe [Code (List Code) Code Code (List Code)]) @@ -3978,7 +3986,7 @@ (macro: #export (type: tokens) {#.doc (text$ ($_ "lux text concat" - "## The type-definition macro." "\n" + "## The type-definition macro." ..new-line "(type: (List a) #Nil (#Cons a (List a)))"))} (let [[exported? tokens'] (export^ tokens) [rec? tokens'] (case tokens' @@ -4211,9 +4219,9 @@ _ ($_ text/compose prefix "/" clean))] (return output)) (fail ($_ "lux text concat" - "Cannot climb the module hierarchy...\n" - "Importing module: " module "\n" - " Relative Root: " relative-root "\n")))))) + "Cannot climb the module hierarchy..." ..new-line + "Importing module: " module ..new-line + " Relative Root: " relative-root ..new-line)))))) (def: (parse-imports nested? relative-root imports) (-> Bit Text (List Code) (Meta (List Importation))) @@ -4497,10 +4505,10 @@ (macro: #export (^open tokens) {#.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" + "## Same as the 'open' macro, but meant to be used as a pattern-matching macro for generating local bindings." ..new-line + "## Takes an 'alias' text for the generated local bindings." ..new-line + "(def: #export (range (^open ''.'') from to)" ..new-line + " (All [a] (-> (Enum a) a a (List a)))" ..new-line " (range' <= succ from to))"))} (case tokens (^ (list& [_ (#Form (list [_ (#Text alias)]))] body branches)) @@ -4548,11 +4556,11 @@ (macro: #export (cond tokens) {#.doc (text$ ($_ "lux text concat" - "## Branching structures with multiple test conditions." "\n" - "(cond (n/even? num) ''even''" "\n" + "## Branching structures with multiple test conditions." ..new-line + "(cond (n/even? num) ''even''" ..new-line " (n/odd? num) ''odd''" - "\n\n" - " ## else-branch" "\n" + __paragraph + " ## else-branch" ..new-line " ''???'')"))} (if (n/= 0 (n/% 2 (list/size tokens))) (fail "cond requires an uneven number of arguments.") @@ -4583,14 +4591,14 @@ (macro: #export (get@ tokens) {#.doc (text$ ($_ "lux text concat" - "## Accesses the value of a record at a given tag." "\n" + "## Accesses the value of a record at a given tag." ..new-line "(get@ #field my-record)" - "\n\n" - "## Can also work with multiple levels of nesting:" "\n" + __paragraph + "## Can also work with multiple levels of nesting:" ..new-line "(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" + __paragraph + "## And, if only the slot/path is given, generates an accessor function:" ..new-line + "(let [getter (get@ [#foo #bar #baz])]" ..new-line " (getter my-record))"))} (case tokens (^ (list [_ (#Tag slot')] record)) @@ -4652,14 +4660,14 @@ (macro: #export (open: tokens) {#.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" + __paragraph + "## For example:" ..new-line "(open: ''i:.'' Number)" - "\n\n" - "## Will generate:" "\n" - "(def: i:+ (:: Number +))" "\n" - "(def: i:- (:: Number -))" "\n" - "(def: i:* (:: Number *))" "\n" + __paragraph + "## Will generate:" ..new-line + "(def: i:+ (:: Number +))" ..new-line + "(def: i:- (:: Number -))" ..new-line + "(def: i:* (:: Number *))" ..new-line "..."))} (case tokens (^ (list [_ (#Text alias)] struct)) @@ -4693,9 +4701,9 @@ (macro: #export (|>> tokens) {#.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" + "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." ..new-line + "(|>> (list/map int/encode) (interpose '' '') (fold text/compose ''''))" ..new-line + "## =>" ..new-line "(function (_ ) (fold text/compose '''' (interpose '' '' (list/map int/encode ))))"))} (do Monad [g!_ (gensym "_") @@ -4704,9 +4712,9 @@ (macro: #export (<<| tokens) {#.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" + "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." ..new-line + "(<<| (fold text/compose '''') (interpose '' '') (list/map int/encode))" ..new-line + "## =>" ..new-line "(function (_ ) (fold text/compose '''' (interpose '' '' (list/map int/encode ))))"))} (do Monad [g!_ (gensym "_") @@ -4744,10 +4752,10 @@ _ (fail ($_ text/compose "Wrong syntax for refer @ " current-module - "\n" (|> options - (list/map code-to-text) - (interpose " ") - (list/fold text/compose ""))))))) + ..new-line (|> options + (list/map code-to-text) + (interpose " ") + (list/fold text/compose ""))))))) (def: (write-refer module-name [r-defs r-opens]) (-> Text Refer (Meta (List Code))) @@ -4833,20 +4841,20 @@ (macro: #export (module: tokens) {#.doc (text$ ($_ "lux text concat" "## Module-definition macro." - "\n\n" + __paragraph "## 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" + __paragraph + "## Example" ..new-line + "(.module: {#.doc ''Some documentation...''}" ..new-line + " [lux #*" ..new-line + " [control" ..new-line + " [''M'' monad #*]]" ..new-line + " [data" ..new-line + " maybe" ..new-line + " [''.'' name (''name/.'' Codec)]]" ..new-line + " [macro" ..new-line + " code]]" ..new-line + " [//" ..new-line " [type (''.'' Equivalence)]])"))} (do Monad [#let [[_meta _imports] (: [(List [Code Code]) (List Code)] @@ -4874,10 +4882,10 @@ (macro: #export (:: tokens) {#.doc (text$ ($_ "lux text concat" - "## Allows accessing the value of a structure's member." "\n" + "## Allows accessing the value of a structure's member." ..new-line "(:: Codec encode)" - "\n\n" - "## Also allows using that value as a function." "\n" + __paragraph + "## Also allows using that value as a function." ..new-line "(:: Codec encode +123)"))} (case tokens (^ (list struct [_ (#Identifier member)])) @@ -4891,14 +4899,14 @@ (macro: #export (set@ tokens) {#.doc (text$ ($_ "lux text concat" - "## Sets the value of a record at a given tag." "\n" + "## Sets the value of a record at a given tag." ..new-line "(set@ #name ''Lux'' lang)" - "\n\n" - "## Can also work with multiple levels of nesting:" "\n" + __paragraph + "## Can also work with multiple levels of nesting:" ..new-line "(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" + __paragraph + "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..new-line + "(let [setter (set@ [#foo #bar #baz] value)] (setter my-record))" ..new-line "(let [setter (set@ [#foo #bar #baz])] (setter value my-record))"))} (case tokens (^ (list [_ (#Tag slot')] value record)) @@ -4978,14 +4986,14 @@ (macro: #export (update@ tokens) {#.doc (text$ ($_ "lux text concat" - "## Modifies the value of a record at a given tag, based on some function." "\n" + "## Modifies the value of a record at a given tag, based on some function." ..new-line "(update@ #age inc person)" - "\n\n" - "## Can also work with multiple levels of nesting:" "\n" + __paragraph + "## Can also work with multiple levels of nesting:" ..new-line "(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" + __paragraph + "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..new-line + "(let [updater (update@ [#foo #bar #baz] func)] (updater my-record))" ..new-line "(let [updater (update@ [#foo #bar #baz])] (updater func my-record))"))} (case tokens (^ (list [_ (#Tag slot')] fun record)) @@ -5051,38 +5059,38 @@ (macro: #export (^template tokens) {#.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" + "## It's similar to do-template, but meant to be used during pattern-matching." ..new-line + "(def: (beta-reduce env type)" ..new-line + " (-> (List Type) Type Type)" ..new-line + " (case type" ..new-line + " (#.Primitive name params)" ..new-line " (#.Primitive name (list/map (beta-reduce env) params))" - "\n\n" - " (^template []" "\n" - " ( left right)" "\n" - " ( (beta-reduce env left) (beta-reduce env right)))" "\n" + __paragraph + " (^template []" ..new-line + " ( left right)" ..new-line + " ( (beta-reduce env left) (beta-reduce env right)))" ..new-line " ([#.Sum] [#.Product])" - "\n\n" - " (^template []" "\n" - " ( left right)" "\n" - " ( (beta-reduce env left) (beta-reduce env right)))" "\n" + __paragraph + " (^template []" ..new-line + " ( left right)" ..new-line + " ( (beta-reduce env left) (beta-reduce env right)))" ..new-line " ([#.Function] [#.Apply])" - "\n\n" - " (^template []" "\n" - " ( old-env def)" "\n" - " (case old-env" "\n" - " #.Nil" "\n" + __paragraph + " (^template []" ..new-line + " ( old-env def)" ..new-line + " (case old-env" ..new-line + " #.Nil" ..new-line " ( env def)" - "\n\n" - " _" "\n" - " type))" "\n" + __paragraph + " _" ..new-line + " type))" ..new-line " ([#.UnivQ] [#.ExQ])" - "\n\n" - " (#.Parameter idx)" "\n" + __paragraph + " (#.Parameter idx)" ..new-line " (default type (list.nth idx env))" - "\n\n" - " _" "\n" - " type" "\n" + __paragraph + " _" ..new-line + " type" ..new-line " ))"))} (case tokens (^ (list& [_ (#Form (list& [_ (#Tuple bindings)] templates))] @@ -5196,7 +5204,7 @@ (-> Nat Cursor Cursor Text) (if (n/= old-line new-line) (text/join (repeat (.int (n/- old-column new-column)) " ")) - (let [extra-lines (text/join (repeat (.int (n/- old-line new-line)) "\n")) + (let [extra-lines (text/join (repeat (.int (n/- old-line new-line)) ..new-line)) space-padding (text/join (repeat (.int (n/- baseline new-column)) " "))] (text/compose extra-lines space-padding)))) @@ -5262,27 +5270,27 @@ (case fragment (#Doc-Comment comment) (|> comment - (text/split "\n") - (list/map (function (_ line) ($_ text/compose "## " line "\n"))) + (text/split ..new-line) + (list/map (function (_ line) ($_ text/compose "## " line ..new-line))) text/join) (#Doc-Example example) (let [baseline (find-baseline-column example) [cursor _] example [_ text] (doc-example->Text (with-baseline baseline cursor) baseline example)] - (text/compose text "\n\n")))) + (text/compose text __paragraph)))) (macro: #export (doc tokens) {#.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" + __paragraph + "## For Example:" ..new-line + "(doc ''Allows arbitrary looping, using the \\''recur\\'' form to re-start the loop.''" ..new-line + " ''Can be used in monadic code to create monadic loops.''" ..new-line + " (loop [count +0" ..new-line + " x init]" ..new-line + " (if (< +10 count)" ..new-line + " (recur (inc count) (f x))" ..new-line " x)))"))} (return (list (` [(~ cursor-code) (#.Text (~ (|> tokens @@ -5489,7 +5497,7 @@ [(bit #0) "#0" [_ (#.Bit #0)]] [(int +123) "+123" [_ (#.Int +123)]] [(frac +123.0) "+123.0" [_ (#.Frac +123.0)]] - [(text "\n") "'\\n'" [_ (#.Text "\n")]] + [(text "123") "'123'" [_ (#.Text "123")]] [(tag ["yolo" "lol"]) "#yolo.lol" [_ (#.Tag ["yolo" "lol"])]] [(identifier ["yolo" "lol"]) "yolo.lol" [_ (#.Identifier ["yolo" "lol"])]] [(form (list (bit #1) (int +123))) "(#1 +123)" (^ [_ (#.Form (list [_ (#.Bit #1)] [_ (#.Int +123)]))])] -- cgit v1.2.3