diff options
author | Eduardo Julian | 2021-08-29 18:30:29 -0400 |
---|---|---|
committer | Eduardo Julian | 2021-08-29 18:30:29 -0400 |
commit | ff537895fe9c24f37a0ce11b640af5d4882571a5 (patch) | |
tree | f59778fa4163277d3ca3a1df450af82a401debb3 /stdlib/documentation.md | |
parent | 1680d4d8bc4046ed4728413f1e7cfd77aa7e84b7 (diff) |
Better parameterized type documentation.
Diffstat (limited to '')
-rw-r--r-- | stdlib/documentation.md | 36468 |
1 files changed, 36468 insertions, 0 deletions
diff --git a/stdlib/documentation.md b/stdlib/documentation.md new file mode 100644 index 000000000..23cf7eed2 --- /dev/null +++ b/stdlib/documentation.md @@ -0,0 +1,36468 @@ +# library/lux + +## Definitions + +### $\_ + +```clojure +Macro +``` + +Right\-association for the application of binary functions over variadic arguments\. + +```clojure +($_ text\composite "Hello, " name ". How are you?") + +... => + +(text\composite "Hello, " (text\composite name ". How are you?")) +``` + +### ' + +```clojure +Macro +``` + +Quotation as a macro\. + +```clojure +(' YOLO) +``` + +### \+\+ + +```clojure +(All (_ a) (-> (I64 a) (I64 a))) +``` + +Increment function\. + +### \-\- + +```clojure +(All (_ a) (-> (I64 a) (I64 a))) +``` + +Decrement function\. + +### \-> + +```clojure +Macro +``` + +Function types\. + +```clojure +... This is the type of a function that takes 2 Ints and returns an Int. + +(-> Int Int Int) +``` + +### : + +```clojure +Macro +``` + +The type\-annotation macro\. + +```clojure +(: (List Int) + (list +1 +2 +3)) +``` + +### :as + +```clojure +Macro +``` + +The type\-coercion macro\. + +```clojure +(:as Dinosaur + (list +1 +2 +3)) +``` + +### :expected + +```clojure +Macro +``` + +Coerces the given expression to the type of whatever is expected\. + +```clojure +(: Dinosaur + (:expected (: (List Nat) + (list 1 2 3)))) +``` + +### :let + +```clojure +Macro +``` + +Local bindings for types\. + +```clojure +(:let [side (Either Int Frac)] + (List [side side])) +``` + +### :of + +```clojure +Macro +``` + +Generates the type corresponding to a given expression\. + +```clojure +(let [my_num +123] + (:of my_num)) + +... == + +Int + +................................................................ +................................................................ + +(:of +123) + +... == + +Int +``` + +### :parameter + +```clojure +Macro +``` + +WARNING: Please stay away from this macro; it's very likely to be removed in a future version of Lux\.Allows you to refer to the type\-variables in a polymorphic function's type, by their index\. + +```clojure +... In the example below, 0 corresponds to the 'a' variable. + +(def: public (of_list list) + (All (_ a) (-> (List a) (Row a))) + (list\mix add + (: (Row (:parameter 0)) + empty) + list)) +``` + +### <<| + +```clojure +Macro +``` + +Similar to the reverse piping macro, but rather than taking an initial object to work on, creates a function for taking it\. + +```clojure +(<<| (mix text\composite "") + (interposed " ") + (list\each int\encoded)) + +... => + +(function (_ <it>) + (mix text\composite "" + (interposed " " + (list\each int\encoded + <it>)))) +``` + +### <| + +```clojure +Macro +``` + +Reverse piping macro\. + +```clojure +(<| (mix text\composite "") + (interposed " ") + (list\each int\encoded) + elems) + +... => + +(mix text\composite "" + (interposed " " + (list\each int\encoded + elems))) +``` + +### Alias + +```clojure +... Type +[Text Text] +``` + +### All + +```clojure +Macro +``` + +Universal quantification\. + +```clojure +(All (_ a) + (-> a a)) + +................................................................ +................................................................ + +... A name can be provided, to specify a recursive type. + +(All (List a) + (Or Any + [a (List a)])) +``` + +### And + +```clojure +Macro +``` + +An alias for the Tuple type constructor\. + +```clojure +(= (Tuple Bit Nat Text) + (And Bit Nat Text)) + +................................................................ +................................................................ + +(= (Tuple) + (And)) +``` + +### \(Ann meta\_data datum\) + +```clojure +... Type +[meta_data datum] +``` + +The type of things that can be annotated with meta\-data of arbitrary types\. + +### Any + +```clojure +... Type +(Ex (Any a) a) +``` + +The type of things whose type is irrelevant\. +It can be used to write functions or data\-structures that can take, or return, anything\. + +### \(Bindings key value\) + +```clojure +... Type +[Nat (List [key value])] +``` + +### Bit + +```clojure +... Type +(primitive "#Bit") +``` + +Your standard, run\-of\-the\-mill boolean values \(as \#0 or \#1 bits\)\. + +### Code + +```clojure +(Or [Text (List ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing))] [((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing) ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)] [((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing) ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)] [((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing) ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)] Nat Nat Nat [(List ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)) ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)] [(List ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)) ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)] [((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing) ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)] [Name ((All (_ a) (Or [Text (List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] Nat Nat Nat [(List (? a)) (? a)] [(List (? a)) (? a)] [(? a) (? a)] [Name (? a)])) Nothing)]) +``` + +The type of Code nodes for Lux syntax\. + +### \(Code' w\) + +```clojure +... Type +(Or Bit Nat Int Rev Frac Text Name Name (List (w (Code' w))) (List (w (Code' w))) (List [(w (Code' w)) (w (Code' w))])) +``` + +### Definition + +```clojure +... Type +[Bit Type Code Any] +``` + +Represents all the data associated with a definition: its type, its annotations, and its value\. + +### \(Either left right\) + +```clojure +... Type +(Or left right) +``` + +A choice between two values of different types\. + +### Ex + +```clojure +Macro +``` + +Existential quantification\. + +```clojure +(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))]) +``` + +### Frac + +```clojure +... Type +(primitive "#Frac") +``` + +Your standard, run\-of\-the\-mill floating\-point \(fractional\) numbers\. + +### Global + +```clojure +... Type +(Or Definition [Bit Type (Or [Text (List Text)] [Text (List Text)])] Label Label Alias) +``` + +Represents all the data associated with a global constant\. + +### \(I64 kind\) + +```clojure +... Type +(primitive "#I64" kind) +``` + +64\-bit integers without any semantics\. + +### Info + +```clojure +... Type +[Text Text Mode] +``` + +Information about the current version and type of compiler that is running\. + +### Int + +```clojure +... Type +(primitive "#I64" (primitive "#Int")) +``` + +Your standard, run\-of\-the\-mill integer numbers\. + +### Interface + +```clojure +Macro +``` + +Interface definition\. + +```clojure +(type: public (Order a) + (Interface + (: (Equivalence a) + &equivalence) + (: (-> a a Bit) + <))) +``` + +### \(List item\) + +```clojure +... Type +(Or Any [item (List item)]) +``` + +A potentially empty list of values\. + +### Location + +```clojure +... Type +[Text Nat Nat] +``` + +Locations are for specifying the location of Code nodes in Lux files during compilation\. + +### Lux + +```clojure +... Type +((All (Lux a) [Info Source Location (Maybe Text) (List [Text Module]) (List Scope) Type_Context (Maybe Type) Nat (List Nat) Any (-> Type Code (Lux a) (Or Text [(Lux a) Any])) Any]) Nothing) +``` + +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\. + +### Macro + +```clojure +... Type +(primitive "#Macro") +``` + +Functions that run at compile\-time and allow you to transform and extend the language in powerful ways\. + +### Macro' + +```clojure +... Type +(-> (List Code) (Meta (List Code))) +``` + +### \(Maybe value\) + +```clojure +... Type +(Or Any value) +``` + +A potentially missing value\. + +### \(Meta it\) + +```clojure +... Type +(-> Lux (Either Text [Lux it])) +``` + +Computations that can have access to the state of the compiler\. +These computations may fail, or modify the state of the compiler\. + +### Mode + +```clojure +... Type +(Or Any Any Any) +``` + +A sign that shows the conditions under which the compiler is running\. + +### Module + +```clojure +... Type +[Nat (List [Text Text]) (List [Text Global]) (List Text) (Maybe Code) Module_State] +``` + +All the information contained within a Lux module\. + +### Module\_State + +```clojure +... Type +(Or Any Any Any) +``` + +### Name + +```clojure +... Type +[Text Text] +``` + +A name\. It is used as part of Lux syntax to represent identifiers and tags\. + +### Nat + +```clojure +... Type +(primitive "#I64" (primitive "#Nat")) +``` + +Natural numbers \(unsigned integers\)\. +They start at zero \(0\) and extend in the positive direction\. + +### Nothing + +```clojure +... Type +(All (Nothing a) a) +``` + +The type of things whose type is undefined\. +Useful for expressions that cause errors or other 'extraordinary' conditions\. + +### Or + +```clojure +Macro +``` + +An alias for the Union type constructor\. + +```clojure +(= (Union Bit Nat Text) + (Or Bit Nat Text)) + +................................................................ +................................................................ + +(= (Union) + (Or)) +``` + +### Rec + +```clojure +Macro +``` + +Parameter\-less recursive types\. + +```clojure +... A name has to be given to the whole type, to use it within its body. + +(Rec Int_List + (Or Any + [Int Int_List])) + +................................................................ +................................................................ + +... Can also be used with type: and labelled-type definitions. + +(type: Type + (Rec @ + (Variant + (#Primitive Text (List @)) + (#Sum @ @) + (#Product @ @) + (#Function @ @) + (#Parameter Nat) + (#Var Nat) + (#Ex Nat) + (#UnivQ (List @) @) + (#ExQ (List @) @) + (#Apply @ @) + (#Named Name @)))) +``` + +### Record + +```clojure +Macro +``` + +Syntax for defining labelled/slotted product/tuple types\. +WARNING: Only use it within the type: macro\. + +```clojure +(type: Refer + (Record + {#refer_defs Referrals + #refer_open (List Openings)})) +``` + +### Ref + +```clojure +... Type +(Or Nat Nat) +``` + +### Rev + +```clojure +... Type +(primitive "#I64" (primitive "#Rev")) +``` + +Fractional numbers that live in the interval \[0,1\)\. +Useful for probability, and other domains that work within that interval\. + +### Scope + +```clojure +... Type +[(List Text) Nat (Bindings Text [Type Nat]) (Bindings Text [Type Ref])] +``` + +### Source + +```clojure +... Type +[Location Nat Text] +``` + +### Text + +```clojure +... Type +(primitive "#Text") +``` + +Your standard, run\-of\-the\-mill string values\. + +### Tuple + +```clojure +Macro +``` + +Tuple types\. + +```clojure +(Tuple Bit Nat Text) + +................................................................ +................................................................ + +(= Any + (Tuple)) +``` + +### Type + +```clojure +... Type +((All (Type a) (Or [Text (List (Type a))] [(Type a) (Type a)] [(Type a) (Type a)] [(Type a) (Type a)] Nat Nat Nat [(List (Type a)) (Type a)] [(List (Type a)) (Type a)] [(Type a) (Type a)] [Name (Type a)])) Nothing) +``` + +This type represents the data\-structures that are used to specify types themselves\. + +### Type\_Context + +```clojure +... Type +[Nat Nat (List [Nat (Maybe Type)])] +``` + +### Union + +```clojure +Macro +``` + +Union types\. + +```clojure +(Union Bit Nat Text) + +................................................................ +................................................................ + +(= Nothing + (Union)) +``` + +### Variant + +```clojure +Macro +``` + +Syntax for defining labelled/tagged sum/union types\. +WARNING: Only use it within the type: macro\. + +```clojure +(type: Referrals + (Variant + #All + (#Only (List Text)) + (#Exclude (List Text)) + #Ignore + #Nothing)) +``` + +### \\ + +```clojure +Macro +``` + +Allows accessing the value of a implementation's member\. + +```clojure +(\ codec encoded) + +................................................................ +................................................................ + +... Also allows using that value as a function. + +(\ codec encoded +123) +``` + +### ^ + +```clojure +Macro +``` + +Macro\-expanding patterns\. +It's a special macro meant to be used with 'case'\. + +```clojure +(case (: (List Int) + (list +1 +2 +3)) + (^ (list x y z)) + (#Some ($_ * x y z)) + + _ + #None) +``` + +### ^@ + +```clojure +Macro +``` + +Allows you to simultaneously bind and de\-structure a value\. + +```clojure +(def: (hash (^@ set [member_hash _])) + (list\mix (function (_ elem acc) + (+ acc + (\ member_hash hash elem))) + 0 + (library/lux/data/collection/set.listset))) +``` + +### ^code + +```clojure +Macro +``` + +Generates pattern\-matching code for Code values in a way that looks like code\-templating\. + +```clojure +(: (Maybe Nat) + (case (` (#0 123 +456.789)) + (^code (#0 (~ [_ (#library/lux.Natnumber)]) +456.789)) + (#library/lux.Somenumber) + + _ + #library/lux.None)) +``` + +### ^multi + +```clojure +Macro +``` + +Multi\-level pattern matching\. +Useful in situations where the result of a branch depends on further refinements on the values being matched\. + +```clojure +(case (split (size static) uri) + (^multi (#Some [chunk uri']) + {(text\= static chunk) #1}) + (match_uri endpoint? parts' uri') + + _ + (#Left (format "Static part " (%t static) " does not match URI: " uri))) + +................................................................ +................................................................ + +... Short-cuts can be taken when using bit tests. + +... The example above can be rewritten as... + +(case (split (size static) uri) + (^multi (#Some [chunk uri']) + (text\= static chunk)) + (match_uri endpoint? parts' uri') + + _ + (#Left (format "Static part " (%t static) " does not match URI: " uri))) +``` + +### ^open + +```clojure +Macro +``` + +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\. + +```clojure +(def: public (range enum from to) + (All (_ a) (-> (Enum a) a a (List a))) + (let [(^open ".") enum] + (loop [end to + output #library/lux.End] + (cond (< end from) + (recur (pred end) (#library/lux.Itemend output)) + + (< from end) + (recur (succ end) (#library/lux.Itemend output)) + + + (#library/lux.Itemend output))))) +``` + +### ^or + +```clojure +Macro +``` + +Or\-patterns\. +It's a special macro meant to be used with 'case'\. + +```clojure +(type: Weekday + (Variant + #Monday + #Tuesday + #Wednesday + #Thursday + #Friday + #Saturday + #Sunday)) + +(def: (weekend? day) + (-> Weekday Bit) + (case day + (^or #Saturday #Sunday) + #1 + + _ + #0)) +``` + +### ^slots + +```clojure +Macro +``` + +Allows you to extract record members as local variables with the same names\. + +```clojure +(let [(^slots [#foo #bar #baz]) quux] + (f foo bar baz)) +``` + +### ^template + +```clojure +Macro +``` + +It's similar to template, but meant to be used during pattern\-matching\. + +```clojure +(def: (reduced env type) + (-> (List Type) Type Type) + (case type + (#library/lux.Primitivename params) + (#library/lux.Primitivename (list\each (reduced env) params)) + + (^template [<tag>] + [(<tag> left right) + (<tag> (reduced env left) (reduced env right))]) + ([#library/lux.Sum][#library/lux.Product]) + + (^template [<tag>] + [(<tag> left right) + (<tag> (reduced env left) (reduced env right))]) + ([#library/lux.Function][#library/lux.Apply]) + + (^template [<tag>] + [(<tag> old_env def) + (case old_env + #library/lux.End + (<tag> env def) + + _ + type)]) + ([#library/lux.UnivQ][#library/lux.ExQ]) + + (#library/lux.Parameteridx) + (else type (library/lux/data/collection/list.itemidx env)) + + _ + type)) +``` + +### ^|> + +```clojure +Macro +``` + +Pipes the value being pattern\-matched against prior to binding it to a variable\. + +```clojure +(case input + (^|> value [++ (% 10) (max 1)]) + (foo value)) +``` + +### \_$ + +```clojure +Macro +``` + +Left\-association for the application of binary functions over variadic arguments\. + +```clojure +(_$ text\composite "Hello, " name ". How are you?") + +... => + +(text\composite (text\composite "Hello, " name) ". How are you?") +``` + +### \` + +```clojure +Macro +``` + +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\. + +```clojure +(` (def: (~ name) + (function ((~' _) (~+ args)) + (~ body)))) +``` + +### \`' + +```clojure +Macro +``` + +Unhygienic quasi\-quotation as a macro\. +Unquote \(~\) and unquote\-splice \(~\+\) must also be used as forms\. + +```clojure +(`' (def: (~ name) + (function (_ (~+ args)) + (~ body)))) +``` + +### \`\` + +```clojure +Macro +``` + +Delimits a controlled \(spliced\) macro\-expansion\. +Uses a \(~~\) special form to specify where to expand\. + +```clojure +(`` (some expression + (~~ (some macro which may yield 0 or more results)))) +``` + +### and + +```clojure +Macro +``` + +Short\-circuiting 'and'\. + +```clojure +(and #1 #0) + +... => + +#0 + +................................................................ +................................................................ + +(and #1 #1) + +... => + +#1 +``` + +### as\_is + +```clojure +Macro +``` + +Given a \(potentially empty\) list of codes, just returns them immediately, without any work done\. +This may seen useless, but it has its utility when dealing with controlled\-macro\-expansion macros\. + +```clojure +(with_expansions [<operands> (as_is 1 + 2 + 3 + 4)] + ($_ + <operands>)) +``` + +### case + +```clojure +Macro +``` + +The pattern\-matching macro\. +Allows the usage of macros within the patterns to provide custom syntax\. + +```clojure +(case (: (List Int) + (list +1 +2 +3)) + (#Item x (#Item y (#Item z #End))) + (#Some ($_ * x y z)) + + _ + #None) +``` + +### char + +```clojure +Macro +``` + +If given a 1\-character text literal, yields the char\-code of the sole character\. + +```clojure +(: Nat + (char "A")) + +... => + +65 +``` + +### comment + +```clojure +Macro +``` + +Throws away any code given to it\. +Great for commenting\-out code, while retaining syntax high\-lighting and formatting in your text editor\. + +```clojure +(comment + (def: (this will not) + (Be Defined) + (because it will be (commented out)))) +``` + +### cond + +```clojure +Macro +``` + +Conditional branching with multiple test conditions\. + +```clojure +(cond (even? num) "WHEN even" + (odd? num) "WHEN odd" + "ELSE") +``` + +### def: + +```clojure +Macro +``` + +Defines global constants/functions\. + +```clojure +(def: branching_exponent + Int + +5) + +................................................................ +................................................................ + +... The type is optional. + +(def: branching_exponent + +5) + +................................................................ +................................................................ + +(def: (pair_list pair) + (-> [Code Code] (List Code)) + (let [[left right] pair] + (list left right))) + +................................................................ +................................................................ + +... Can pattern-match on the inputs to functions. + +(def: (pair_list [left right]) + (-> [Code Code] (List Code)) + (list left right)) +``` + +### exec + +```clojure +Macro +``` + +Sequential execution of expressions \(great for side\-effects\)\. + +```clojure +(exec + (log! "#1") + (log! "#2") + (log! "#3") + "YOLO") +``` + +### false + +```clojure +Bit +``` + +The boolean FALSE value\. + +### for + +```clojure +Macro +``` + +Selects the appropriate code for a given target\-platform when compiling Lux to it\. +Look\-up the available targets in library/lux/target\. + +```clojure +(def: js "JavaScript") + +(for {"JVM" (do jvm stuff) + documentation/lux.js(do js stuff)} + (do default stuff)) +``` + +### function + +```clojure +Macro +``` + +Syntax for creating functions\. + +```clojure +(: (All (_ a b) + (-> a b a)) + (function (_ x y) + x)) + +................................................................ +................................................................ + +... Allows for giving the function itself a name, for the sake of recursion. + +(: (-> Nat Nat) + (function (factorial n) + (case n + 0 1 + _ (* n (factorial (-- n)))))) +``` + +### global + +```clojure +Bit +``` + +The export policy for public/global definitions\. + +### i64 + +```clojure +(-> (I64 Any) I64) +``` + +Safe type\-casting for I64 values\. + +### if + +```clojure +Macro +``` + +Picks which expression to evaluate based on a bit test value\. + +```clojure +(if #1 + "Oh, yeah!" + "Aw hell naw!") + +... => + +... Oh, yeah! + +................................................................ +................................................................ + +(if #0 + "Oh, yeah!" + "Aw hell naw!") + +... => + +... Aw hell naw! +``` + +### implementation + +```clojure +Macro +``` + +Express a value that implements an interface\. + +```clojure +(: (Order Int) + (implementation + (def: &equivalence + equivalence) + (def: (< reference subject) + (< reference subject)))) +``` + +### implementation: + +```clojure +Macro +``` + +Interface implementation\. + +```clojure +(implementation: public order + (Order Int) + (def: &equivalence + equivalence) + (def: (< test subject) + (< test subject))) +``` + +### int + +```clojure +(-> (I64 Any) Int) +``` + +Safe type\-casting for I64 values\. + +### let + +```clojure +Macro +``` + +Creates local bindings\. +Can \(optionally\) use pattern\-matching macros when binding\. + +```clojure +(let [x (foo bar) + y (baz quux)] + (op x y)) +``` + +### list + +```clojure +Macro +``` + +List literals\. + +```clojure +(: (List Nat) + (list 0 1 2 3)) +``` + +### list& + +```clojure +Macro +``` + +List literals, with the last element being a tail\-list\. + +```clojure +(: (List Nat) + (list& 0 1 2 3 + (: (List Nat) + (list 4 5 6)))) +``` + +### local + +```clojure +Bit +``` + +The export policy for private/local definitions\. + +### loop + +```clojure +Macro +``` + +Allows arbitrary looping, using the 'recur' form to re\-start the loop\. +Can be used in monadic code to create monadic loops\. + +```clojure +(loop [count +0 + x init] + (if (< +10 count) + (recur (++ count) (f x)) + x)) + +................................................................ +................................................................ + +... Loops can also be given custom names. + +(loop my_loop + [count +0 + x init] + (if (< +10 count) + (my_loop (++ count) (f x)) + x)) +``` + +### macro: + +```clojure +Macro +``` + +Macro\-definition macro\. + +```clojure +(macro: public (name_of tokens) + (case tokens + (^template [<tag>] + [(^ (list [_ (<tag> [module name])])) + (in (list (` [(~ (text$ module)) (~ (text$ name))])))]) + ([#Identifier] [#Tag]) + + _ + (failure "Wrong syntax for name_of"))) +``` + +### module: + +```clojure +Macro +``` + +Module\-definition macro\. + +```clojure +(module: + [lux #* + [control + ["M" monad #*]] + [data + maybe + ["." name ("#/." codec)]] + [macro + code]] + [// + [type ("." equivalence)]]) +``` + +### module\_separator + +```clojure +Text +``` + +Character used to separate the parts of module names\. +Value: "/" + +### name\_of + +```clojure +Macro +``` + +Given an identifier or a tag, gives back a 2 tuple with the module and name parts, both as Text\. + +```clojure +(name_of #library/lux.doc) + +... => + +["library/lux" "doc"] +``` + +### nat + +```clojure +(-> (I64 Any) Nat) +``` + +Safe type\-casting for I64 values\. + +### not + +```clojure +(-> Bit Bit) +``` + +Bit negation\. + +```clojure +(not #1) + +... => + +#0 + +................................................................ +................................................................ + +(not #0) + +... => + +#1 +``` + +### open: + +```clojure +Macro +``` + +Opens a implementation and generates a definition for each of its members \(including nested members\)\. + +```clojure +(open: "i:." order) + +... => + +(def: i:= (\ order =)) + +(def: i:< (\ order <)) +``` + +### or + +```clojure +Macro +``` + +Short\-circuiting 'or'\. + +```clojure +(or #1 #0) + +... => + +#1 + +................................................................ +................................................................ + +(or #0 #0) + +... => + +#0 +``` + +### panic\! + +```clojure +(-> Text Nothing) +``` + +Causes an error, with the given error message\. + +```clojure +(panic! "OH NO!") +``` + +### prelude\_module + +```clojure +Text +``` + +The name of the prelude module +Value: "library/lux" + +### primitive + +```clojure +Macro +``` + +Macro to treat define new primitive types\. + +```clojure +(primitive "java.lang.Object") + +................................................................ +................................................................ + +(primitive "java.util.List" [(primitive "java.lang.Long")]) +``` + +### private + +```clojure +Bit +``` + +The export policy for private/local definitions\. + +### public + +```clojure +Bit +``` + +The export policy for public/global definitions\. + +### rev + +```clojure +(-> (I64 Any) Rev) +``` + +Safe type\-casting for I64 values\. + +### revised@ + +```clojure +Macro +``` + +Modifies the value of a record at a given tag, based on some function\. + +```clojure +(revised@ #age ++ person) + +................................................................ +................................................................ + +... Can also work with multiple levels of nesting. + +(revised@ [#foo #bar #baz] func my_record) + +................................................................ +................................................................ + +... And, if only the slot/path and (optionally) the value are given, generates a mutator function. + +(let [updater (revised@ [#foo #bar #baz] func)] + (updater my_record)) + +(let [updater (revised@ [#foo #bar #baz])] + (updater func my_record)) +``` + +### same? + +```clojure +(All (_ a) (-> a a Bit)) +``` + +Tests whether the 2 values are identical \(not just 'equal'\)\. + +```clojure +... This one should succeed: + +(let [value +5] + (same? value + value)) + +................................................................ +................................................................ + +... This one should fail: + +(same? +5 + (+ +2 +3)) +``` + +### static + +```clojure +Macro +``` + +Resolves the names of definitions to their values at compile\-time, assuming their values are either: +\* Bit +\* Nat +\* Int +\* Rev +\* Frac +\* Text + +```clojure +(def: my_nat 123) + +(def: my_text "456") + +(and (case [my_nat my_text] + (^ (static [documentation/lux.my_natdocumentation/lux.my_text])) + true + + _ + false) + (case [my_nat my_text] + (^ [(static documentation/lux.my_nat)(static documentation/lux.my_text)]) + true + + _ + false)) +``` + +### template + +```clojure +Macro +``` + +```clojure +... By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary. + +(template [<name> <diff>] + [(def: public <name> + (-> Int Int) + (+ <diff>))] + [++ +1] + [-- -1]) +``` + +### template: + +```clojure +Macro +``` + +Define macros in the style of template and ^template\. +For simple macros that do not need any fancy features\. + +```clojure +(template: (square x) + (* x x)) +``` + +### true + +```clojure +Bit +``` + +The boolean TRUE value\. + +### try + +```clojure +Macro +``` + +```clojure +(: Foo + (case (: (Either Text Bar) + (try (: Bar + (risky computation which may panic)))) + (#library/lux.Rightsuccess) + (: Foo + (do something after success)) + + (#library/lux.Lefterror) + (: Foo + (recover from error)))) +``` + +### type + +```clojure +Macro +``` + +Takes a type expression and returns its representation as data\-structure\. + +```clojure +(type (All (_ a) + (Maybe (List a)))) +``` + +### type: + +```clojure +Macro +``` + +The type\-definition macro\. + +```clojure +(type: (List a) + #End + (#Item a (List a))) +``` + +### undefined + +```clojure +Macro +``` + +Meant to be used as a stand\-in for functions with undefined implementations\. +Undefined expressions will type\-check against everything, so they make good dummy implementations\. +However, if an undefined expression is ever evaluated, it will raise a runtime error\. + +```clojure +(def: (square x) + (-> Int Int) + (undefined)) +``` + +### value@ + +```clojure +Macro +``` + +Accesses the value of a record at a given tag\. + +```clojure +(value@ #field my_record) + +................................................................ +................................................................ + +... Can also work with multiple levels of nesting. + +(value@ [#foo #bar #baz] my_record) + +................................................................ +................................................................ + +... And, if only the slot/path is given, generates an accessor function. + +(let [getter (value@ [#foo #bar #baz])] + (getter my_record)) +``` + +### with@ + +```clojure +Macro +``` + +Sets the value of a record at a given tag\. + +```clojure +(with@ #name "Lux" lang) + +................................................................ +................................................................ + +... Can also work with multiple levels of nesting. + +(with@ [#foo #bar #baz] value my_record) + +................................................................ +................................................................ + +... And, if only the slot/path and (optionally) the value are given, generates a mutator function. + +(let [setter (with@ [#foo #bar #baz] value)] + (setter my_record)) + +(let [setter (with@ [#foo #bar #baz])] + (setter value my_record)) +``` + +### with\_expansions + +```clojure +Macro +``` + +Controlled macro\-expansion\. +Bind an arbitraty number of Code nodes resulting from macro\-expansion to local bindings\. +Wherever a binding appears, the bound Code nodes will be spliced in there\. + +```clojure +(def: test + Test + (with_expansions + [<tests> (template [<function> <parameter> <expected>] + [(cover [<function>] + (compare <text> + (\ codec encoded <function> <parameter>)))] + + [bit #1 "#1"] + [int +123 "+123"] + [frac +123.0 "+123.0"] + [text "123" "'123'"] + [tag ["yolo" "lol"] "#yolo.lol"] + [identifier ["yolo" "lol"] "yolo.lol"] + [form (list (bit #1)) "(#1)"] + [tuple (list (bit #1)) "[#1]"] + [record (list [(bit #1) (int +123)]) "{#1 +123}"])] + + ($_ and + <tests>))) +``` + +### |> + +```clojure +Macro +``` + +Piping macro\. + +```clojure +(|> elems + (list\each int\encoded) + (interposed " ") + (mix text\composite "")) + +... => + +(mix text\composite "" + (interposed " " + (list\each int\encoded + elems))) +``` + +### |>> + +```clojure +Macro +``` + +Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it\. + +```clojure +(|>> (list\each int\encoded) + (interposed " ") + (mix text\composite "")) + +... => + +(function (_ <it>) + (mix text\composite "" + (interposed " " + (list\each int\encoded <it>)))) +``` + +## Missing documentation + +1. `` Label `` +1. `` __adjusted_quantified_type__ `` +1. `` macro `` + +___ + +# library/lux/abstract/apply + +## Definitions + +### \(Apply f\) + +```clojure +... .Type +[(library/lux/abstract/functor.Functor f) (All (_ b c) (-> (f b) (f (-> b c)) (f c)))] +``` + +Applicative functors\. + +### composite + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (Apply a) (Apply b) (Apply (All (_ c) (a (b c)))))) +``` + +Applicative functor composition\. + +___ + +# library/lux/abstract/codec + +## Definitions + +### \(Codec medium value\) + +```clojure +... .Type +[(-> value medium) (-> medium (library/lux/control/try.Try value))] +``` + +A way to move back\-and\-forth between a type and an alternative representation for it\. + +### composite + +```clojure +(All (_ a b c) (-> (Codec c b) (Codec b a) (Codec c a))) +``` + +Codec composition\. + +```clojure +(: (Codec c a) + (composite (: (Codec c b) + cb_codec) + (: (Codec b a) + ba_codec))) +``` + +___ + +# library/lux/abstract/comonad + +## Definitions + +### \(CoMonad \!\) + +```clojure +... .Type +[(library/lux/abstract/functor.Functor !) (All (_ b) (-> (! b) b)) (All (_ b) (-> (! b) (! (! b))))] +``` + +Co\-monads are the opposite/complement to monads\. +Co\-monadic structures are often infinite in size and built upon lazily\-evaluated functions\. + +### be + +```clojure +.Macro +``` + +A co\-monadic parallel to the 'do' macro\. + +```clojure +(let [square (function (_ n) (* n n))] + (be comonad + [inputs (iterate ++ +2)] + (square (out inputs)))) +``` + +___ + +# library/lux/abstract/comonad/cofree + +## Definitions + +### \(CoFree \! it\) + +```clojure +... .Type +[it (! (CoFree ! it))] +``` + +The CoFree CoMonad\. + +### comonad + +```clojure +(All (_ a) (-> (library/lux/abstract/functor.Functor a) (library/lux/abstract/comonad.CoMonad (CoFree a)))) +``` + +### functor + +```clojure +(All (_ a) (-> (library/lux/abstract/functor.Functor a) (library/lux/abstract/functor.Functor (CoFree a)))) +``` + +___ + +# library/lux/abstract/enum + +## Definitions + +### \(Enum it\) + +```clojure +... .Type +[(library/lux/abstract/order.Order it) (-> it it) (-> it it)] +``` + +Enumerable types, with a notion of moving forward and backwards through a type's instances\. + +### range + +```clojure +(All (_ a) (-> (Enum a) a a (.List a))) +``` + +An inclusive \[from, to\] range of values\. + +```clojure +(range enum from to) +``` + +___ + +# library/lux/abstract/equivalence + +## Definitions + +### \(Equivalence it\) + +```clojure +... .Type +(-> it it .Bit) +``` + +Equivalence for a type's instances\. + +### functor + +```clojure +(library/lux/abstract/functor/contravariant.Functor Equivalence) +``` + +### rec + +```clojure +(All (_ a) (-> (-> (Equivalence a) (Equivalence a)) (Equivalence a))) +``` + +A recursive equivalence combinator\. + +```clojure +(rec recursive_equivalence) +``` + +___ + +# library/lux/abstract/functor + +## Definitions + +### \(And left right\) + +```clojure +... .Type +(All (_ c) [(left c) (right c)]) +``` + +### \(Fix \!\) + +```clojure +... .Type +(! (Fix !)) +``` + +### \(Functor \!\) + +```clojure +... .Type +(All (_ b c) (-> (-> b c) (! b) (! c))) +``` + +### \(Or left right\) + +```clojure +... .Type +(All (_ c) (Or (left c) (right c))) +``` + +### \(Then outer inner\) + +```clojure +... .Type +(All (_ c) (outer (inner c))) +``` + +### composite + +```clojure +(All (_ a b) (-> (Functor a) (Functor b) (Functor (Then a b)))) +``` + +Functor composition\. + +### product + +```clojure +(All (_ a b) (-> (Functor a) (Functor b) (Functor (And a b)))) +``` + +Product composition for functors\. + +### sum + +```clojure +(All (_ a b) (-> (Functor a) (Functor b) (Functor (Or a b)))) +``` + +Co\-product \(sum\) composition for functors\. + +___ + +# library/lux/abstract/functor/contravariant + +## Definitions + +### \(Functor \!\) + +```clojure +... .Type +(All (_ b c) (-> (-> c b) (! b) (! c))) +``` + +The contravariant functor\. + +___ + +# library/lux/abstract/hash + +## Definitions + +### \(Hash it\) + +```clojure +... .Type +[(library/lux/abstract/equivalence.Equivalence it) (-> it .Nat)] +``` + +A way to produce hash\-codes for a type's instances\. + +### functor + +```clojure +(library/lux/abstract/functor/contravariant.Functor Hash) +``` + +___ + +# library/lux/abstract/interval + +## Definitions + +### \(Interval it\) + +```clojure +... .Type +[(library/lux/abstract/enum.Enum it) it it] +``` + +A representation of top and bottom boundaries for an ordered type\. + +### after? + +```clojure +(All (_ a) (-> a (Interval a) .Bit)) +``` + +### before? + +```clojure +(All (_ a) (-> a (Interval a) .Bit)) +``` + +### between + +```clojure +(All (_ a) (-> (library/lux/abstract/enum.Enum a) a a (Interval a))) +``` + +### borders? + +```clojure +(All (_ a) (-> (Interval a) a .Bit)) +``` + +Where a value is at the border of an interval\. + +### complement + +```clojure +(All (_ a) (-> (Interval a) (Interval a))) +``` + +The inverse of an interval\. + +### ends\_with? + +```clojure +(All (_ a) (-> a (Interval a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (library/lux/abstract/equivalence.Equivalence (Interval a))) +``` + +### finishes? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +### inner? + +```clojure +(All (_ a) (-> (Interval a) .Bit)) +``` + +### intersection + +```clojure +(All (_ a) (-> (Interval a) (Interval a) (Interval a))) +``` + +An interval spanned by both predecessors\. + +### meets? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +Whether an interval meets another one on its bottom/lower side\. + +### nested? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +### outer? + +```clojure +(All (_ a) (-> (Interval a) .Bit)) +``` + +### overlaps? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +### precedes? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +### singleton + +```clojure +(All (_ a) (-> (library/lux/abstract/enum.Enum a) a (Interval a))) +``` + +An interval where both top and bottom are the same value\. + +```clojure +(singleton enum elem) +``` + +### singleton? + +```clojure +(All (_ a) (-> (Interval a) .Bit)) +``` + +### starts? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +### starts\_with? + +```clojure +(All (_ a) (-> a (Interval a) .Bit)) +``` + +### succeeds? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +### touches? + +```clojure +(All (_ a) (-> (Interval a) (Interval a) .Bit)) +``` + +### union + +```clojure +(All (_ a) (-> (Interval a) (Interval a) (Interval a))) +``` + +An interval that spans both predecessors\. + +### within? + +```clojure +(All (_ a) (-> (Interval a) a .Bit)) +``` + +___ + +# library/lux/abstract/mix + +## Definitions + +### \(Mix structure\) + +```clojure +... .Type +(All (_ b c) (-> (-> c b b) b (structure c) b)) +``` + +Iterate over a structure's values to build a summary value\. + +### with\_monoid + +```clojure +(All (_ a b) (-> (library/lux/abstract/monoid.Monoid b) (Mix a) (a b) b)) +``` + +Mix a mixable structure using the monoid's identity as the initial value\. + +```clojure +(with_monoid monoid mix value) +``` + +___ + +# library/lux/abstract/monad + +## Definitions + +### \(Monad it\) + +```clojure +... .Type +[(library/lux/abstract/functor.Functor it) (All (_ b) (-> b (it b))) (All (_ b) (-> (it (it b)) (it b)))] +``` + +A monad is a monoid in the category of endofunctors\. +What's the problem? + +### all + +```clojure +(All (_ a b) (-> (Monad a) (.List (a b)) (a (.List b)))) +``` + +Run all the monadic values in the list and produce a list of the base values\. + +```clojure +(all monad) +``` + +### do + +```clojure +.Macro +``` + +Macro for easy concatenation of monadic operations\. + +```clojure +(do monad + [y (f1 x) + z (f2 z)] + (in (f3 z))) +``` + +### each + +```clojure +(All (_ a b c) (-> (Monad a) (-> b (a c)) (.List b) (a (.List c)))) +``` + +Apply a monadic function to all values in a list\. + +```clojure +(each monad function items) +``` + +### mix + +```clojure +(All (_ a b c) (-> (Monad a) (-> c b (a b)) b (.List c) (a b))) +``` + +Mix a list with a monadic function\. + +```clojure +(mix monad function initial_value items) +``` + +### only + +```clojure +(All (_ a b c) (-> (Monad a) (-> b (a .Bit)) (.List b) (a (.List b)))) +``` + +Filter the values in a list with a monadic function\. + +```clojure +(only monad predicate items) +``` + +### then + +```clojure +(All (_ a b c) (-> (Monad a) (-> b (a c)) (a b) (a c))) +``` + +Apply a function with monadic effects to a monadic value and yield a new monadic value\. + +```clojure +(then monad function) +``` + +___ + +# library/lux/abstract/monad/free + +## Definitions + +### \(Free \! it\) + +```clojure +... .Type +(Or it (! (Free ! it))) +``` + +The Free Monad\. + +### apply + +```clojure +(All (_ a) (-> (library/lux/abstract/functor.Functor a) (library/lux/abstract/apply.Apply (Free a)))) +``` + +### functor + +```clojure +(All (_ a) (-> (library/lux/abstract/functor.Functor a) (library/lux/abstract/functor.Functor (Free a)))) +``` + +### monad + +```clojure +(All (_ a) (-> (library/lux/abstract/functor.Functor a) (library/lux/abstract/monad.Monad (Free a)))) +``` + +___ + +# library/lux/abstract/monoid + +## Definitions + +### \(Monoid it\) + +```clojure +... .Type +[it (-> it it it)] +``` + +A way to compose values\. +Includes an identity value which does not alter any other value when combined with\. + +### and + +```clojure +(All (_ a b) (-> (Monoid a) (Monoid b) (Monoid [a b]))) +``` + +___ + +# library/lux/abstract/order + +## Definitions + +### <= + +```clojure +Comparison +``` + +Less than or equal\. + +### > + +```clojure +Comparison +``` + +Greater than\. + +### >= + +```clojure +Comparison +``` + +Greater than or equal\. + +### \(Choice it\) + +```clojure +... .Type +(-> (Order it) it it it) +``` + +A choice comparison between two values, with the knowledge of how to order them\. + +### \(Comparison it\) + +```clojure +... .Type +(-> (Order it) it it .Bit) +``` + +An arbitrary comparison between two values, with the knowledge of how to order them\. + +### \(Order it\) + +```clojure +... .Type +[(library/lux/abstract/equivalence.Equivalence it) (-> it it .Bit)] +``` + +A signature for types that possess some sense of ordering among their elements\. + +### functor + +```clojure +(library/lux/abstract/functor/contravariant.Functor Order) +``` + +### max + +```clojure +Choice +``` + +Maximum\. + +### min + +```clojure +Choice +``` + +Minimum\. + +___ + +# library/lux/abstract/predicate + +## Definitions + +### \(Predicate it\) + +```clojure +... .Type +(-> it .Bit) +``` + +A question that can be asked of a value, yield either false \(\#0\) or true \(\#1\)\. + +### all + +```clojure +Predicate +``` + +A predicate that always succeeds\. + +### and + +```clojure +(All (_ a) (-> (Predicate a) (Predicate a) (Predicate a))) +``` + +A predicate that meets both predecessors\. + +### complement + +```clojure +(All (_ a) (-> (Predicate a) (Predicate a))) +``` + +The opposite of a predicate\. + +### difference + +```clojure +(All (_ a) (-> (Predicate a) (Predicate a) (Predicate a))) +``` + +A predicate that meeds 'base', but not 'sub'\. + +### functor + +```clojure +(library/lux/abstract/functor/contravariant.Functor Predicate) +``` + +### intersection + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (Predicate a))) +``` + +### none + +```clojure +Predicate +``` + +A predicate that always fails\. + +### or + +```clojure +(All (_ a) (-> (Predicate a) (Predicate a) (Predicate a))) +``` + +A predicate that meets either predecessor\. + +### rec + +```clojure +(All (_ a) (-> (-> (Predicate a) (Predicate a)) (Predicate a))) +``` + +Ties the knot for a recursive predicate\. + +### union + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (Predicate a))) +``` + +___ + +# library/lux/control/concatenative + +## Definitions + +### && + +```clojure +(All (_ a b c) (-> [[c a] b] [c a b])) +``` + +Groups the 2 topmost stack values as a 2\-tuple\. + +### => + +```clojure +.Macro +``` + +Concatenative function types\. + +```clojure +(=> [Nat] [Nat]) + +................................................................ +................................................................ + +(All (_ a) + (-> a (=> [] [a]))) + +................................................................ +................................................................ + +(All (_ t) + (=> [t] [])) + +................................................................ +................................................................ + +(All (_ a b c) + (=> [a b c] [b c a])) + +................................................................ +................................................................ + +(All (_ ___a ___z) + (=> {then (=> ___a ___z) + else (=> ___a ___z)} + ___a [Bit then else] ___z)) +``` + +### ? + +```clojure +(All (_ a b) (-> [[[b .Bit] a] a] [b a])) +``` + +Choose the top value when \#0 and the second\-to\-top when \#1\. + +### apply + +```clojure +.Macro +``` + +A generator for functions that turn arity N functions into arity N concatenative functions\. + +```clojure +(: (=> [Nat] [Nat]) + ((apply 1) ++)) +``` + +### apply/1 + +```clojure +(All (_ a b) (-> (-> a b) (All (_ c) (-> [c a] [c b])))) +``` + +Lift a function of arity 1 into a concatenative function of arity 1\. + +```clojure + ( + + 1function_of_arity_1) +``` + +### apply/2 + +```clojure +(All (_ a b c) (-> (-> a b c) (All (_ d) (-> [[d a] b] [d c])))) +``` + +Lift a function of arity 2 into a concatenative function of arity 2\. + +```clojure + ( + + 2function_of_arity_2) +``` + +### apply/3 + +```clojure +(All (_ a b c d) (-> (-> a b c d) (All (_ e) (-> [[[e a] b] c] [e d])))) +``` + +Lift a function of arity 3 into a concatenative function of arity 3\. + +```clojure + ( + + 3function_of_arity_3) +``` + +### apply/4 + +```clojure +(All (_ a b c d e) (-> (-> a b c d e) (All (_ f) (-> [[[[f a] b] c] d] [f e])))) +``` + +Lift a function of arity 4 into a concatenative function of arity 4\. + +```clojure + ( + + 4function_of_arity_4) +``` + +### apply/5 + +```clojure +(All (_ a b c d e f) (-> (-> a b c d e f) (All (_ g) (-> [[[[[g a] b] c] d] e] [g f])))) +``` + +Lift a function of arity 5 into a concatenative function of arity 5\. + +```clojure + ( + + + 5function_of_arity_5) +``` + +### apply/6 + +```clojure +(All (_ a b c d e f g) (-> (-> a b c d e f g) (All (_ h) (-> [[[[[[h a] b] c] d] e] f] [h g])))) +``` + +Lift a function of arity 6 into a concatenative function of arity 6\. + +```clojure + ( + + + 6function_of_arity_6) +``` + +### apply/7 + +```clojure +(All (_ a b c d e f g h) (-> (-> a b c d e f g h) (All (_ i) (-> [[[[[[[i a] b] c] d] e] f] g] [i h])))) +``` + +Lift a function of arity 7 into a concatenative function of arity 7\. + +```clojure + ( + + + 7function_of_arity_7) +``` + +### apply/8 + +```clojure +(All (_ a b c d e f g h i) (-> (-> a b c d e f g h i) (All (_ j) (-> [[[[[[[[j a] b] c] d] e] f] g] h] [j i])))) +``` + +Lift a function of arity 8 into a concatenative function of arity 8\. + +```clojure + ( + + + 8function_of_arity_8) +``` + +### call + +```clojure +(All (_ a b) (-> [a (-> a b)] b)) +``` + +Executes an anonymous block on the stack\. + +### compose + +```clojure +(All (_ a b c d) (-> [[d (-> a b)] (-> b c)] [d (-> a c)])) +``` + +Function composition\. + +```clojure +(library/lux/math/number/nat.=(library/lux/math/number/nat.+2 sample) + (||> (push sample) + (push (|>> (push 1) n/+)) + (push (|>> (push 1) n/+)) + compose + call)) +``` + +### dip + +```clojure +(All (_ a b) (-> [[a b] (-> a a)] [a b])) +``` + +Executes a block on the stack, save for the topmost value\. + +### dip/2 + +```clojure +(All (_ a b c) (-> [[[a b] c] (-> a a)] [[a b] c])) +``` + +Executes a block on the stack, save for the 2 topmost values\. + +### do + +```clojure +(All (_ a b) (-> [[a (-> b [a .Bit])] (-> a b)] [[b (-> b [a .Bit])] (-> a b)])) +``` + +Do\-while loop expression\. + +```clojure +(library/lux/math/number/nat.=(++ sample) + (||> (push sample) + (push (push false)) + (push (|>> (push 1) n/+)) + do while)) +``` + +### drop + +```clojure +(All (_ a b) (-> [b a] b)) +``` + +Drop/pop a value from the top of the stack\. + +### dup + +```clojure +(All (_ a b) (-> [b a] [[b a] a])) +``` + +Duplicate the top of the stack\. + +### f/% + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Frac])) +``` + +% for Frac arithmetic\. + +### f/\* + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Frac])) +``` + +\* for Frac arithmetic\. + +### f/\+ + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Frac])) +``` + +\+ for Frac arithmetic\. + +### f/\- + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Frac])) +``` + +\- for Frac arithmetic\. + +### f// + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Frac])) +``` + +/ for Frac arithmetic\. + +### f/< + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Bit])) +``` + +< for Frac arithmetic\. + +### f/<= + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Bit])) +``` + +<= for Frac arithmetic\. + +### f/= + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Bit])) +``` + += for Frac arithmetic\. + +### f/> + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Bit])) +``` + +> for Frac arithmetic\. + +### f/>= + +```clojure +(All (_ a) (-> [[a .Frac] .Frac] [a .Bit])) +``` + +>= for Frac arithmetic\. + +### i/% + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Int])) +``` + +% for Int arithmetic\. + +### i/\* + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Int])) +``` + +\* for Int arithmetic\. + +### i/\+ + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Int])) +``` + +\+ for Int arithmetic\. + +### i/\- + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Int])) +``` + +\- for Int arithmetic\. + +### i// + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Int])) +``` + +/ for Int arithmetic\. + +### i/< + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Bit])) +``` + +< for Int arithmetic\. + +### i/<= + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Bit])) +``` + +<= for Int arithmetic\. + +### i/= + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Bit])) +``` + += for Int arithmetic\. + +### i/> + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Bit])) +``` + +> for Int arithmetic\. + +### i/>= + +```clojure +(All (_ a) (-> [[a .Int] .Int] [a .Bit])) +``` + +>= for Int arithmetic\. + +### if + +```clojure +(All (_ a b) (-> [[[a .Bit] (-> a b)] (-> a b)] b)) +``` + +If expression\. + +```clojure +(same? "then" + (||> (push true) + (push "then") + (push "else") + if)) +``` + +### loop + +```clojure +(All (_ a) (-> [a (-> a [a .Bit])] a)) +``` + +Executes a block as a loop until it yields \#0 to stop\. + +### n/% + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Nat])) +``` + +% for Nat arithmetic\. + +### n/\* + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Nat])) +``` + +\* for Nat arithmetic\. + +### n/\+ + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Nat])) +``` + +\+ for Nat arithmetic\. + +### n/\- + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Nat])) +``` + +\- for Nat arithmetic\. + +### n// + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Nat])) +``` + +/ for Nat arithmetic\. + +### n/< + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Bit])) +``` + +< for Nat arithmetic\. + +### n/<= + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Bit])) +``` + +<= for Nat arithmetic\. + +### n/= + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Bit])) +``` + += for Nat arithmetic\. + +### n/> + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Bit])) +``` + +> for Nat arithmetic\. + +### n/>= + +```clojure +(All (_ a) (-> [[a .Nat] .Nat] [a .Bit])) +``` + +>= for Nat arithmetic\. + +### nip + +```clojure +(All (_ a b c) (-> [[c a] b] [c b])) +``` + +Drop the second\-to\-last value from the top of the stack\. + +### partial + +```clojure +(All (_ a b c) (-> [[a c] (-> [a c] b)] [a (-> a b)])) +``` + +Partial application\. + +```clojure +(library/lux/math/number/nat.=(library/lux/math/number/nat.+sample sample) + (||> (push sample) + (push sample) + (push n/+) + partial + call)) +``` + +### push + +```clojure +(All (_ a) (-> a (All (_ b) (-> b [b a])))) +``` + +Push a value onto the stack\. + +### r/% + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Rev])) +``` + +% for Rev arithmetic\. + +### r/\* + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Rev])) +``` + +\* for Rev arithmetic\. + +### r/\+ + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Rev])) +``` + +\+ for Rev arithmetic\. + +### r/\- + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Rev])) +``` + +\- for Rev arithmetic\. + +### r// + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Rev])) +``` + +/ for Rev arithmetic\. + +### r/< + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Bit])) +``` + +< for Rev arithmetic\. + +### r/<= + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Bit])) +``` + +<= for Rev arithmetic\. + +### r/= + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Bit])) +``` + += for Rev arithmetic\. + +### r/> + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Bit])) +``` + +> for Rev arithmetic\. + +### r/>= + +```clojure +(All (_ a) (-> [[a .Rev] .Rev] [a .Bit])) +``` + +>= for Rev arithmetic\. + +### rotL + +```clojure +(All (_ a b c d) (-> [[[d a] b] c] [[[d b] c] a])) +``` + +Rotes the 3 topmost stack values to the left\. + +### rotR + +```clojure +(All (_ a b c d) (-> [[[d a] b] c] [[[d c] a] b])) +``` + +Rotes the 3 topmost stack values to the right\. + +### swap + +```clojure +(All (_ a b c) (-> [[c a] b] [[c b] a])) +``` + +Swaps the 2 topmost stack values\. + +### when + +```clojure +(All (_ a) (-> [[a .Bit] (-> a a)] a)) +``` + +Only execute the block when \#1\. + +### while + +```clojure +(All (_ a b) (-> [[a (-> a [b .Bit])] (-> b a)] b)) +``` + +While loop expression\. + +```clojure +(library/lux/math/number/nat.=(library/lux/math/number/nat.+distance start) + (||> (push start) + (push (|>> dup + (push start) n/- + (push distance) n/<)) + (push (|>> (push 1) n/+)) + while)) +``` + +### word: + +```clojure +.Macro +``` + +A named concatenative function\. + +```clojure +(word: square + (=> [Nat] [Nat]) + + dup + (apply/2 library/lux/math/number/nat.*)) +``` + +### ||> + +```clojure +.Macro +``` + +A self\-contained sequence of concatenative instructions\. + +```clojure +(same? value + (||> (push sample))) + +................................................................ +................................................................ + +(||> (push 123) + dup + n/=) +``` + +### ||L + +```clojure +(All (_ a b c) (-> [c a] [c (Or a b)])) +``` + +Left\-injects the top into sum\. + +### ||R + +```clojure +(All (_ a b c) (-> [c b] [c (Or a b)])) +``` + +Right\-injects the top into sum\. + +___ + +# library/lux/control/concurrency/actor + +The actor model of concurrency\. + +## Definitions + +### \(Actor state\) + +```clojure +... .Type +(primitive "library/lux/control/concurrency/actor.Actor" state) +``` + +An entity that can react to messages \(mail\) sent to it concurrently\. + +### \(Behavior input state\) + +```clojure +... .Type +[(-> input state) (-> (Mail state) state (Actor state) (library/lux/control/concurrency/async.Async (library/lux/control/try.Try state)))] +``` + +An actor's behavior when mail is received and when a fatal error occurs\. + +### \(Mail state\) + +```clojure +... .Type +(-> state (Actor state) (library/lux/control/concurrency/async.Async (library/lux/control/try.Try state))) +``` + +A one\-way message sent to an actor, without expecting a reply\. + +### \(Message state output\) + +```clojure +... .Type +(-> state (Actor state) (library/lux/control/concurrency/async.Async (library/lux/control/try.Try [state output]))) +``` + +A two\-way message sent to an actor, expecting a reply\. + +### \(Obituary state\) + +```clojure +... .Type +[.Text state (.List (-> state (Actor state) (library/lux/control/concurrency/async.Async (library/lux/control/try.Try state))))] +``` + +Details on the death of an actor\. + +### Stop + +```clojure +... .Type +(library/lux/control/io.IO .Any) +``` + +A signal to stop an actor from observing a channel\. + +### actor + +```clojure +.Macro +``` + +Defines an anonymous actor, with its behavior and internal state\. +Messages for the actor must be defined after the on\_mail handler\. + +```clojure +(actor {Nat + 123} + ((on_mail message state self) + (message (++ state) self))) +``` + +### actor: + +```clojure +.Macro +``` + +Defines a named actor, with its behavior and internal state\. +Messages for the actor must be defined after the on\_mail handler\. + +```clojure +(actor: .public(stack a) + {} + + (List a) + + ((on_mail mail state self) + (do (try.with async.monad) + [.let[_ (debug.log! "BEFORE")] + output (mail state self) + .let[_ (debug.log! "AFTER")]] + (in output))) + + (message: .public(push {value a} state self) + (List a) + (let [state' (#library/lux.Itemvalue state)] + (async.resolved (#try.Success [state' state']))))) + +(actor: .publiccounter + {} + + Nat + + (message: .public(count! {increment Nat} state self) + Any + (let [state' (n.+ increment state)] + (async.resolved (#try.Success [state' state'])))) + + (message: .public(read! state self) + Nat + (async.resolved (#try.Success [state state])))) +``` + +### alive? + +```clojure +(All (_ a) (-> (Actor a) (library/lux/control/io.IO .Bit))) +``` + +### dead + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### default + +```clojure +(All (_ a) (Behavior a a)) +``` + +Default actor behavior\. + +### mail\! + +```clojure +(All (_ a) (-> (Mail a) (Actor a) (library/lux/control/io.IO (library/lux/control/try.Try .Any)))) +``` + +Send mail to an actor\. + +### message: + +```clojure +.Macro +``` + +A message can access the actor's state through the state parameter\. +A message can also access the actor itself through the self parameter\. +A message's output must be an async containing a 2\-tuple with the updated state and a return value\. +A message may succeed or fail \(in case of failure, the actor dies\)\. + +```clojure +(actor: .public(stack a) + {} + + (List a) + + ((on_mail mail state self) + (do (try.with async.monad) + [.let[_ (debug.log! "BEFORE")] + output (mail state self) + .let[_ (debug.log! "AFTER")]] + (in output))) + + (message: .public(push {value a} state self) + (List a) + (let [state' (#library/lux.Itemvalue state)] + (async.resolved (#try.Success [state' state']))))) + +(actor: .publiccounter + {} + + Nat + + (message: .public(count! {increment Nat} state self) + Any + (let [state' (n.+ increment state)] + (async.resolved (#try.Success [state' state'])))) + + (message: .public(read! state self) + Nat + (async.resolved (#try.Success [state state])))) +``` + +### obituary + +```clojure +(All (_ a) (-> (Actor a) (library/lux/control/concurrency/async.Async (Obituary a)))) +``` + +Await for an actor to stop working\. + +### obituary' + +```clojure +(All (_ a) (-> (Actor a) (library/lux/control/io.IO (.Maybe (Obituary a))))) +``` + +### observe\! + +```clojure +(All (_ a b) (-> (-> a Stop (Mail b)) (library/lux/control/concurrency/frp.Channel a) (Actor b) (library/lux/control/io.IO .Any))) +``` + +Use an actor to observe a channel by transforming each datum +flowing through the channel into mail the actor can process\. +Can stop observing the channel by executing the Stop value\. + +### poison\! + +```clojure +(All (_ a) (-> (Actor a) (library/lux/control/io.IO (library/lux/control/try.Try .Any)))) +``` + +Kills the actor by sending mail that will kill it upon processing, +but allows the actor to handle previous mail\. + +### poisoned + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### spawn\! + +```clojure +(All (_ a b) (-> (Behavior a b) a (library/lux/control/io.IO (Actor b)))) +``` + +Given a behavior and initial state, spawns an actor and returns it\. + +### tell\! + +```clojure +(All (_ a b) (-> (Message a b) (Actor a) (library/lux/control/concurrency/async.Async (library/lux/control/try.Try b)))) +``` + +Communicate with an actor through message\-passing\. + +___ + +# library/lux/control/concurrency/async + +## Definitions + +### \(Async it\) + +```clojure +... .Type +(primitive "library/lux/control/concurrency/async.Async" it) +``` + +Represents values produced by asynchronous computations \(unlike IO, which is synchronous\)\. + +### \(Resolver it\) + +```clojure +... .Type +(-> it (library/lux/control/io.IO .Bit)) +``` + +The function used to give a value to an async\. +Will signal 'true' if the async has been resolved for the 1st time, 'false' otherwise\. + +### after + +```clojure +(All (_ a) (-> .Nat a (Async a))) +``` + +Delivers a value after a certain period has passed\. + +```clojure +(after milli_seconds value) +``` + +### and + +```clojure +(All (_ a b) (-> (Async a) (Async b) (Async [a b]))) +``` + +Combines the results of both asyncs, in\-order\. + +```clojure +(and left right) +``` + +### apply + +```clojure +(library/lux/abstract/apply.Apply Async) +``` + +### async + +```clojure +(All (_ a) (-> .Any [(Async a) (Resolver a)])) +``` + +Creates a fresh async that has not been resolved yet\. + +```clojure +(async _) +``` + +### delay + +```clojure +(-> .Nat (Async .Any)) +``` + +An async that will be resolved after the specified amount of milli\-seconds\. + +```clojure +(delay milli_seconds) +``` + +### either + +```clojure +(All (_ a) (-> (Async a) (Async a) (Async a))) +``` + +Yields the results of whichever async gets resolved first\. +You cannot tell which one was resolved first\. + +```clojure +(either left right) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Async) +``` + +### future + +```clojure +(All (_ a) (-> (library/lux/control/io.IO a) (Async a))) +``` + +Runs an I/O computation on its own thread\. +Returns an async that will eventually host its result\. + +```clojure +(future computation) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Async) +``` + +### or + +```clojure +(All (_ a b) (-> (Async a) (Async b) (Async (Or a b)))) +``` + +Yields the results of whichever async gets resolved first\. +You can tell which one was resolved first through pattern\-matching\. + +```clojure +(or left right) +``` + +### resolved + +```clojure +(All (_ a) (-> a (Async a))) +``` + +Produces an async that has already been resolved to the given value\. + +```clojure +(resolved value) +``` + +### resolved? + +```clojure +(All (_ a) (-> (Async a) (library/lux/control/io.IO .Bit))) +``` + +Checks whether an async's value has already been resolved\. + +### schedule\! + +```clojure +(All (_ a) (-> .Nat (library/lux/control/io.IO a) (Async a))) +``` + +Runs an I/O computation on its own thread \(after a specified delay\)\. +Returns an async that will eventually host its result\. + +```clojure +(schedule! milli_seconds computation) +``` + +### upon\! + +```clojure +(All (_ a) (-> (-> a (library/lux/control/io.IO .Any)) (Async a) (library/lux/control/io.IO .Any))) +``` + +Executes the given function as soon as the async has been resolved\. + +```clojure +(upon! function async) +``` + +### value + +```clojure +(All (_ a) (-> (Async a) (library/lux/control/io.IO (.Maybe a)))) +``` + +Polls an async for its value\. + +### within + +```clojure +(All (_ a) (-> .Nat (Async a) (Async (.Maybe a)))) +``` + +Wait for an async to be resolved within the specified amount of milli\-seconds\. + +```clojure +(within milli_seconds async) +``` + +___ + +# library/lux/control/concurrency/atom + +## Definitions + +### \(Atom it\) + +```clojure +... .Type +(primitive "library/lux/control/concurrency/atom.Atom" it) +``` + +Atomic references that are safe to mutate concurrently\. + +### atom + +```clojure +(All (_ a) (-> a (Atom a))) +``` + +### compare\_and\_swap\! + +```clojure +(All (_ a) (-> a a (Atom a) (library/lux/control/io.IO .Bit))) +``` + +Only mutates an atom if you can present its current value\. +That guarantees that atom was not updated since you last read from it\. + +### read\! + +```clojure +(All (_ a) (-> (Atom a) (library/lux/control/io.IO a))) +``` + +### update\! + +```clojure +(All (_ a) (-> (-> a a) (Atom a) (library/lux/control/io.IO [a a]))) +``` + +Updates an atom by applying a function to its current value\. +If it fails to update it \(because some other process wrote to it first\), it will retry until it succeeds\. +The retries will be done with the new values of the atom, as they show up\. + +### write\! + +```clojure +(All (_ a) (-> a (Atom a) (library/lux/control/io.IO a))) +``` + +Writes the given value to an atom\. +If it fails to write it \(because some other process wrote to it first\), it will retry until it succeeds\. + +___ + +# library/lux/control/concurrency/frp + +## Definitions + +### \(Channel it\) + +```clojure +... .Type +(library/lux/control/concurrency/async.Async (.Maybe [it (Channel it)])) +``` + +An asynchronous channel to distribute values\. + +### \(Sink it\) + +```clojure +... .Type +[(library/lux/control/io.IO (library/lux/control/try.Try .Any)) (-> it (library/lux/control/io.IO (library/lux/control/try.Try .Any)))] +``` + +The tail\-end of a channel, which can be written\-to to fee the channel\. + +### \(Subscriber it\) + +```clojure +... .Type +(-> it (library/lux/control/io.IO (.Maybe .Any))) +``` + +A function that can receive every value fed into a channel\. + +### apply + +```clojure +(library/lux/abstract/apply.Apply Channel) +``` + +### channel + +```clojure +(All (_ a) (-> .Any [(Channel a) (Sink a)])) +``` + +Creates a brand\-new channel and hands it over, along with the sink to write to it\. + +```clojure +(channel _) +``` + +### channel\_is\_already\_closed + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### distinct + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (Channel a) (Channel a))) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Channel) +``` + +### iterations + +```clojure +(All (_ a b) (-> (-> a (library/lux/control/concurrency/async.Async (.Maybe [a b]))) a (Channel b))) +``` + +### list + +```clojure +(All (_ a) (-> (Channel a) (library/lux/control/concurrency/async.Async (.List a)))) +``` + +### mix + +```clojure +(All (_ a b) (-> (-> b a (library/lux/control/concurrency/async.Async a)) a (Channel b) (library/lux/control/concurrency/async.Async a))) +``` + +Asynchronous mix over channels\. + +```clojure +(mix f init channel) +``` + +### mixes + +```clojure +(All (_ a b) (-> (-> b a (library/lux/control/concurrency/async.Async a)) a (Channel b) (Channel a))) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Channel) +``` + +### of\_async + +```clojure +(All (_ a) (-> (library/lux/control/concurrency/async.Async a) (Channel a))) +``` + +A one\-element channel containing the output from an async\. + +```clojure +(of_async async) +``` + +### only + +```clojure +(All (_ a) (-> (-> a .Bit) (Channel a) (Channel a))) +``` + +Produces a new channel based on the old one, only with values +that pass the test\. + +```clojure +(only pass? channel) +``` + +### periodic + +```clojure +(-> .Nat [(Channel .Any) (Sink .Any)]) +``` + +### poll + +```clojure +(All (_ a) (-> .Nat (library/lux/control/io.IO a) [(Channel a) (Sink a)])) +``` + +### sequential + +```clojure +(All (_ a) (-> .Nat (.List a) (Channel a))) +``` + +Transforms the given list into a channel with the same elements\. + +```clojure +(sequential milli_seconds values) +``` + +### subscribe\! + +```clojure +(All (_ a) (-> (Subscriber a) (Channel a) (library/lux/control/io.IO .Any))) +``` + +___ + +# library/lux/control/concurrency/semaphore + +## Definitions + +### Barrier + +```clojure +... .Type +(primitive "library/lux/control/concurrency/semaphore.Barrier") +``` + +A barrier that blocks all processes from proceeding until a given number of processes are parked at the barrier\. + +### Limit + +```clojure +... .Type +(library/lux/type/refinement.Refined .Nat (primitive "{New Type @"library/lux/control/concurrency/semaphore",126,2 0}")) +``` + +A limit for barriers\. + +### Mutex + +```clojure +... .Type +(primitive "library/lux/control/concurrency/semaphore.Mutex") +``` + +A mutual\-exclusion lock that can only be acquired by one process at a time\. + +### Semaphore + +```clojure +... .Type +(primitive "library/lux/control/concurrency/semaphore.Semaphore") +``` + +A tool for controlling access to resources by multiple concurrent processes\. + +### barrier + +```clojure +(-> Limit Barrier) +``` + +### block\! + +```clojure +(-> Barrier (library/lux/control/concurrency/async.Async .Any)) +``` + +Wait on a barrier until all processes have arrived and met the barrier's limit\. + +### limit + +```clojure +(library/lux/type/refinement.Refiner .Nat (primitive "{New Type @"library/lux/control/concurrency/semaphore",126,2 0}")) +``` + +Produce a limit for a barrier\. + +### mutex + +```clojure +(-> .Any Mutex) +``` + +Creates a brand\-new mutex\. + +```clojure +(mutex _) +``` + +### semaphore + +```clojure +(-> .Nat Semaphore) +``` + +```clojure +(semaphore initial_open_positions) +``` + +### semaphore\_is\_maxed\_out + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### signal\! + +```clojure +(Ex (_ a) (-> Semaphore (library/lux/control/concurrency/async.Async (library/lux/control/try.Try .Int)))) +``` + +Signal to a semaphore that you're done with your work, and that there is a new open position\. + +```clojure +(signal! semaphore) +``` + +### synchronize\! + +```clojure +(All (_ a) (-> Mutex (library/lux/control/io.IO (library/lux/control/concurrency/async.Async a)) (library/lux/control/concurrency/async.Async a))) +``` + +Runs the procedure with exclusive control of the mutex\. + +```clojure +(synchronize! mutex procedure) +``` + +### wait\! + +```clojure +(Ex (_ a) (-> Semaphore (library/lux/control/concurrency/async.Async .Any))) +``` + +Wait on a semaphore until there are open positions\. +After finishing your work, you must 'signal' to the semaphore that you're done\. + +```clojure +(wait! semaphore) +``` + +___ + +# library/lux/control/concurrency/stm + +## Definitions + +### \(STM it\) + +```clojure +... .Type +(-> Tx [Tx it]) +``` + +A computation which updates a transaction and produces a value\. + +### \(Var it\) + +```clojure +... .Type +(primitive "library/lux/control/concurrency/stm.Var" it) +``` + +A mutable cell containing a value, and observers that will be alerted of any change to it\. + +### apply + +```clojure +(library/lux/abstract/apply.Apply STM) +``` + +### commit\! + +```clojure +(All (_ a) (-> (STM a) (library/lux/control/concurrency/async.Async a))) +``` + +Commits a transaction and returns its result \(asynchronously\)\. +Note that a transaction may be re\-run an indeterminate number of times if other transactions involving the same variables successfully commit first\. +For this reason, it's important to note that transactions must be free from side\-effects, such as I/O\. + +```clojure +(commit! procedure) +``` + +### follow\! + +```clojure +(All (_ a) (-> (Var a) (library/lux/control/io.IO [(library/lux/control/concurrency/frp.Channel a) (library/lux/control/concurrency/frp.Sink a)]))) +``` + +Creates a channel that will receive all changes to the value of the given var\. + +```clojure +(follow! target) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor STM) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad STM) +``` + +### read + +```clojure +(All (_ a) (-> (Var a) (STM a))) +``` + +### update + +```clojure +(All (_ a) (-> (-> a a) (Var a) (STM [a a]))) +``` + +Update a var's value, and return a tuple with the old and the new values\. + +```clojure +(update function var) +``` + +### var + +```clojure +(All (_ a) (-> a (Var a))) +``` + +Creates a new STM var, with a default value\. + +```clojure +(var value) +``` + +### write + +```clojure +(All (_ a) (-> a (Var a) (STM .Any))) +``` + +___ + +# library/lux/control/concurrency/thread + +## Definitions + +### parallelism + +```clojure +.Nat +``` + +How many processes can run in parallel\. + +### schedule\! + +```clojure +(-> .Nat (library/lux/control/io.IO .Any) (library/lux/control/io.IO .Any)) +``` + +Executes an I/O procedure after some milli\-seconds\. + +```clojure +(schedule! milli_seconds action) +``` + +___ + +# library/lux/control/continuation + +## Definitions + +### \(Cont input output\) + +```clojure +... .Type +(-> (-> input output) output) +``` + +Continuations\. + +### apply + +```clojure +(All (_ a) (library/lux/abstract/apply.Apply (All (_ b) (Cont b a)))) +``` + +### continued + +```clojure +(All (_ a b) (-> (-> a b) (Cont a b) b)) +``` + +Continues a continuation thunk\. + +```clojure +(continued next cont) +``` + +### functor + +```clojure +(All (_ a) (library/lux/abstract/functor.Functor (All (_ b) (Cont b a)))) +``` + +### monad + +```clojure +(All (_ a) (library/lux/abstract/monad.Monad (All (_ b) (Cont b a)))) +``` + +### pending + +```clojure +.Macro +``` + +Turns any expression into a function that is pending a continuation\. + +```clojure +(pending (some_function some_input)) +``` + +### portal + +```clojure +(All (_ a b c) (-> a (Cont [(-> a (Cont b c)) a] c))) +``` + +### reset + +```clojure +(All (_ a b) (-> (Cont a a) (Cont a b))) +``` + +### result + +```clojure +(All (_ a) (-> (Cont a a) a)) +``` + +Forces a continuation thunk to be evaluated\. + +```clojure +(result cont) +``` + +### shift + +```clojure +(All (_ a) (-> (-> (-> a (Cont a a)) (Cont a a)) (Cont a a))) +``` + +### with\_current + +```clojure +(All (_ a b c) (-> (-> (-> a (Cont b c)) (Cont a c)) (Cont a c))) +``` + +Call with current continuation\. + +```clojure +(with_current + (function (_ go) + (do monad + [.let[nexus (function (nexus val) + (go [nexus val]))] + _ (go [nexus init])] + (in (undefined))))) +``` + +___ + +# library/lux/control/exception + +Pure\-Lux exception\-handling functionality\. + +## Definitions + +### \(Exception it\) + +```clojure +... .Type +[.Text (-> it .Text)] +``` + +An exception provides a way to decorate error messages\. + +### assertion + +```clojure +(All (_ a) (-> (Exception a) a .Bit (library/lux/control/try.Try .Any))) +``` + +### error + +```clojure +(All (_ a) (-> (Exception a) a .Text)) +``` + +Constructs an error message from an exception\. + +```clojure +(error exception message) +``` + +### except + +```clojure +(All (_ a b) (-> (Exception a) a (library/lux/control/try.Try b))) +``` + +Decorate an error message with an Exception and lift it into the error\-handling context\. + +```clojure +(except exception message) +``` + +### exception: + +```clojure +.Macro +``` + +Define a new exception type\. +It mostly just serves as a way to tag error messages for later catching\. + +```clojure +... Simple case: + +(exception: .publicsome_exception) + +................................................................ +................................................................ + +... Complex case: + +(exception: .public[arbitrary type variables] (some_exception {optional Text} {arguments Int}) + optional_body) +``` + +### listing + +```clojure +(All (_ a) (-> (-> a .Text) (.List a) .Text)) +``` + +A numbered report of the entries on a list\. +NOTE: 0\-based numbering\. + +```clojure +(listing format entries) +``` + +### match? + +```clojure +(All (_ a) (-> (Exception a) .Text .Bit)) +``` + +Is this exception the cause of the error message? + +```clojure +(match? exception error) +``` + +### otherwise + +```clojure +(All (_ a) (-> (-> .Text a) (library/lux/control/try.Try a) a)) +``` + +If no handler could be found to catch the exception, then run a function as a last\-resort measure\. + +```clojure +(otherwise else try) +``` + +### report + +```clojure +.Macro +``` + +An error report\. + +```clojure +(: Text + (report ["Row 0" value/0] + ["Row 1" value/1] + ,,, + ["Row N" value/N])) +``` + +### when + +```clojure +(All (_ a b) (-> (Exception a) (-> .Text b) (library/lux/control/try.Try b) (library/lux/control/try.Try b))) +``` + +If a particular exception is detected on a possibly\-erroneous value, handle it\. +If no exception was detected, or a different one from the one being checked, then pass along the original value\. + +```clojure +(when exception then try) +``` + +### with + +```clojure +(All (_ a b) (-> (Exception a) a (library/lux/control/try.Try b) (library/lux/control/try.Try b))) +``` + +If a computation fails, prepends the exception to the error\. + +```clojure +(with exception message computation) +``` + +___ + +# library/lux/control/function + +## Definitions + +### composite + +```clojure +(All (_ a b c) (-> (-> b c) (-> a b) a c)) +``` + +Function composition\. + +```clojure +(= ((composite f g) "foo") + (f (g "foo"))) +``` + +### constant + +```clojure +(All (_ a) (-> a (All (_ b) (-> b a)))) +``` + +Create constant functions\. + +```clojure +(= ((constant "foo") "bar") + "foo") +``` + +### flipped + +```clojure +(All (_ a b c) (-> (-> a b c) b a c)) +``` + +Flips the order of the arguments of a function\. + +```clojure +(= ((flipped f) "foo" "bar") + (f "bar" "foo")) +``` + +### identity + +```clojure +(All (_ a) (-> a a)) +``` + +Identity function\. +Does nothing to its argument and just returns it\. + +```clojure +(same? (identity value) + value) +``` + +### monoid + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (-> a a))) +``` + +### on + +```clojure +(All (_ a b) (-> a (-> a b) b)) +``` + +Simple 1\-argument function application\. + +```clojure +(on input function) +``` + +___ + +# library/lux/control/function/contract + +## Definitions + +### post + +```clojure +.Macro +``` + +Post\-conditions\. +Given a predicate and an expression to run, evaluates the expression and then tests the output with the predicate\. +If the predicate returns \#1, returns the value of the expression\. +Otherwise, an error is raised\. + +```clojure +(post i.even? + (i.+ +2 +2)) +``` + +### post\_condition\_failed + +```clojure +(library/lux/control/exception.Exception .Code) +``` + +### pre + +```clojure +.Macro +``` + +Pre\-conditions\. +Given a test and an expression to run, only runs the expression if the test passes\. +Otherwise, an error is raised\. + +```clojure +(pre (i.= +4 (i.+ +2 +2)) + (foo +123 +456 +789)) +``` + +### pre\_condition\_failed + +```clojure +(library/lux/control/exception.Exception .Code) +``` + +___ + +# library/lux/control/function/memo + +## Definitions + +### \(Memo input output\) + +```clojure +... .Type +(library/lux/control/function/mixin.Recursive input (library/lux/control/state.State (library/lux/data/collection/dictionary.Dictionary input output) output)) +``` + +### closed + +```clojure +(All (_ a b) (-> (library/lux/abstract/hash.Hash a) (Memo a b) a b)) +``` + +Memoization confined to a single invocation to the function \(not counting any subsequent recursive invocations\)\. +Memoized results will be re\-used during recursive invocations, but cannot be accessed after the main invocation has ended\. + +```clojure +(closed hash memo) +``` + +### memoization + +```clojure +(All (_ a b) (library/lux/control/function/mixin.Mixin a (library/lux/control/state.State (library/lux/data/collection/dictionary.Dictionary a b) b))) +``` + +### none + +```clojure +(All (_ a b) (-> (library/lux/abstract/hash.Hash a) (Memo a b) a b)) +``` + +No memoization at all\. +This is useful as a test control when measuring the effect of using memoization\. + +```clojure +(none hash memo) +``` + +### open + +```clojure +(All (_ a b) (-> (Memo a b) [(library/lux/data/collection/dictionary.Dictionary a b) a] [(library/lux/data/collection/dictionary.Dictionary a b) b])) +``` + +Memoization where the memoized results can be re\-used accross invocations\. + +```clojure +(open memo) +``` + +___ + +# library/lux/control/function/mixin + +## Definitions + +### \(Mixin input output\) + +```clojure +... .Type +(-> (-> input output) (-> input output) input output) +``` + +A partially\-defined function which can be mixed with others to inherit their behavior\. + +### \(Recursive input output\) + +```clojure +... .Type +(-> (-> input output) input output) +``` + +An indirectly recursive function\. + +### advice + +```clojure +(All (_ a b) (-> (library/lux/abstract/predicate.Predicate a) (Mixin a b) (Mixin a b))) +``` + +Only apply then mixin when the input meets some criterion\. + +```clojure +(advice when then) +``` + +### after + +```clojure +(All (_ a b c) (-> (library/lux/abstract/monad.Monad a) (-> b c (a .Any)) (Mixin b (a c)))) +``` + +Executes an action after doing the main work\. + +```clojure +(after monad action) +``` + +### before + +```clojure +(All (_ a b c) (-> (library/lux/abstract/monad.Monad a) (-> b (a .Any)) (Mixin b (a c)))) +``` + +Executes an action before doing the main work\. + +```clojure +(before monad action) +``` + +### fixed + +```clojure +(All (_ a b) (-> (Mixin a b) a b)) +``` + +Given a mixin, produces a normal function\. + +```clojure +(fixed f) +``` + +### mixed + +```clojure +(All (_ a b) (-> (Mixin a b) (Mixin a b) (Mixin a b))) +``` + +Produces a new mixin, where the behavior of the child can make use of the behavior of the parent\. + +```clojure +(mixed parent child) +``` + +### monoid + +```clojure +(All (_ a b) (library/lux/abstract/monoid.Monoid (Mixin a b))) +``` + +### nothing + +```clojure +Mixin +``` + +A mixin that does nothing and just delegates work to the next mixin\. + +### of\_recursive + +```clojure +(All (_ a b) (-> (Recursive a b) (Mixin a b))) +``` + +Transform an indirectly recursive function into a mixin\. + +```clojure +(of_recursive recursive) +``` + +___ + +# library/lux/control/function/mutual + +## Definitions + +### def: + +```clojure +.Macro +``` + +Globally\-defined mutually\-recursive functions\. + +```clojure +(def: + [.public(even? number) + (-> Nat Bit) + (case number + 0 true + _ (odd? (-- number)))] + + [.public(odd? number) + (-> Nat Bit) + (case number + 0 false + _ (even? (-- number)))]) +``` + +### let + +```clojure +.Macro +``` + +Locally\-defined mutually\-recursive functions\. + +```clojure +(let [(even? number) + (-> Nat Bit) + (case number + 0 true + _ (odd? (-- number))) + + (odd? number) + (-> Nat Bit) + (case number + 0 false + _ (even? (-- number)))] + (and (even? 4) + (odd? 5))) +``` + +___ + +# library/lux/control/io + +A method for abstracting I/O and effectful computations to make it safe while writing pure functional code\. + +## Definitions + +### \(IO it\) + +```clojure +... .Type +(primitive "library/lux/control/io.IO" it) +``` + +A type that represents synchronous, effectful computations that may interact with the outside world\. + +### apply + +```clojure +(library/lux/abstract/apply.Apply IO) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor IO) +``` + +### io + +```clojure +.Macro +``` + +Delays the evaluation of an expression, by wrapping it in an IO 'thunk'\. +Great for wrapping effectful computations \(which will not be performed until the IO is 'run\!'\)\. + +```clojure +(io (exec + (log! msg) + "Some value...")) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad IO) +``` + +### run\! + +```clojure +(All (_ a b) (-> (IO b) b)) +``` + +A way to execute IO computations and perform their side\-effects\. + +___ + +# library/lux/control/lazy + +## Definitions + +### \(Lazy it\) + +```clojure +... .Type +(primitive "library/lux/control/lazy.Lazy" it) +``` + +A value specified by an expression that is calculated only at the last moment possible\. +Afterwards, the value is cached for future reference\. + +### apply + +```clojure +(library/lux/abstract/apply.Apply Lazy) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Lazy a)))) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Lazy) +``` + +### lazy + +```clojure +.Macro +``` + +Specifies a lazy value by providing the expression that computes it\. + +```clojure +(lazy eager_computation) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Lazy) +``` + +### value + +```clojure +(All (_ a) (-> (Lazy a) a)) +``` + +___ + +# library/lux/control/maybe + +## Definitions + +### apply + +```clojure +(library/lux/abstract/apply.Apply .Maybe) +``` + +### else + +```clojure +.Macro +``` + +Allows you to provide a default value that will be used +if a \(Maybe x\) value turns out to be \#\.None\. +Note: the expression for the default value will not be computed if the base computation succeeds\. + +```clojure +(else +20 (#library/lux.Some+10)) + +... => + ++10 + +................................................................ +................................................................ + +(else +20 #library/lux.None) + +... => + ++20 +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (.Maybe a)))) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor .Maybe) +``` + +### hash + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (library/lux/abstract/hash.Hash (.Maybe a)))) +``` + +### lifted + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (a b) (a (.Maybe b)))) +``` + +Wraps a monadic value with Maybe machinery\. + +```clojure +(lifted monad) +``` + +### list + +```clojure +(All (_ a) (-> (.Maybe a) (.List a))) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad .Maybe) +``` + +### monoid + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (.Maybe a))) +``` + +### trusted + +```clojure +(All (_ a) (-> (.Maybe a) a)) +``` + +Assumes that a Maybe value is a \#\.Some and yields its value\. +Raises/throws a runtime error otherwise\. +WARNING: Use with caution\. + +```clojure +(trusted trusted_computation) +``` + +### when + +```clojure +.Macro +``` + +Can be used as a guard in \(co\)monadic be/do expressions\. + +```clojure +(do monad + [value (do_something 1 2 3) + when (passes_test? value)] + (do_something_else 4 5 6)) +``` + +### with + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (library/lux/abstract/monad.Monad (All (_ b) (a (.Maybe b)))))) +``` + +___ + +# library/lux/control/parser + +## Definitions + +### \(Parser state it\) + +```clojure +... .Type +(-> state (library/lux/control/try.Try [state it])) +``` + +A generic parser\. + +### after + +```clojure +(All (_ a b c) (-> (Parser a b) (Parser a c) (Parser a c))) +``` + +Run the parser after another one \(whose output is ignored\)\. + +```clojure +(after param subject) +``` + +### and + +```clojure +(All (_ a b c) (-> (Parser a b) (Parser a c) (Parser a [b c]))) +``` + +Sequencing combinator\. + +```clojure +(and first second) +``` + +### apply + +```clojure +(All (_ a) (library/lux/abstract/apply.Apply (Parser a))) +``` + +### assertion + +```clojure +(All (_ a) (-> .Text .Bit (Parser a .Any))) +``` + +Fails with the given message if the test is \#0\. + +```clojure +(assertion message test) +``` + +### at\_least + +```clojure +(All (_ a b) (-> .Nat (Parser a b) (Parser a (.List b)))) +``` + +Parse at least N times\. + +```clojure +(at_least amount parser) +``` + +### at\_most + +```clojure +(All (_ a b) (-> .Nat (Parser a b) (Parser a (.List b)))) +``` + +Parse at most N times\. + +```clojure +(at_most amount parser) +``` + +### before + +```clojure +(All (_ a b c) (-> (Parser a b) (Parser a c) (Parser a c))) +``` + +Run the parser before another one \(whose output is ignored\)\. + +```clojure +(before param subject) +``` + +### between + +```clojure +(All (_ a b) (-> .Nat .Nat (Parser a b) (Parser a (.List b)))) +``` + +```clojure +(between minimum additional parser) +``` + +### codec + +```clojure +(All (_ a b c) (-> (library/lux/abstract/codec.Codec b c) (Parser a b) (Parser a c))) +``` + +Decode the output of a parser using a codec\. + +```clojure +(codec codec parser) +``` + +### either + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a b) (Parser a b))) +``` + +Homogeneous alternative combinator\. + +```clojure +(either this that) +``` + +### else + +```clojure +(All (_ a b) (-> b (Parser a b) (Parser a b))) +``` + +If the given parser fails, returns the default value\. + +```clojure +(else value parser) +``` + +### exactly + +```clojure +(All (_ a b) (-> .Nat (Parser a b) (Parser a (.List b)))) +``` + +Parse exactly N times\. + +```clojure +(exactly amount parser) +``` + +### failure + +```clojure +(All (_ a b) (-> .Text (Parser a b))) +``` + +Always fail with this 'message'\. + +```clojure +(failure message) +``` + +### functor + +```clojure +(All (_ a) (library/lux/abstract/functor.Functor (Parser a))) +``` + +### lifted + +```clojure +(All (_ a b) (-> (library/lux/control/try.Try b) (Parser a b))) +``` + +Lift a potentially failed computation into a parser\. + +```clojure +(lifted operation) +``` + +### many + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a (.List b)))) +``` + +1\-or\-more combinator\. + +```clojure +(many parser) +``` + +### maybe + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a (.Maybe b)))) +``` + +Optionality combinator\. + +```clojure +(maybe parser) +``` + +### monad + +```clojure +(All (_ a) (library/lux/abstract/monad.Monad (Parser a))) +``` + +### not + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a .Any))) +``` + +Only succeeds when the underlying parser fails\. + +```clojure +(not parser) +``` + +### only + +```clojure +(All (_ a b) (-> (-> b .Bit) (Parser a b) (Parser a b))) +``` + +Only succeed when the parser's output passes a test\. + +```clojure +(only test parser) +``` + +### or + +```clojure +(All (_ a b c) (-> (Parser a b) (Parser a c) (Parser a (Or b c)))) +``` + +Heterogeneous alternative combinator\. + +```clojure +(or left right) +``` + +### parses + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a .Any))) +``` + +Ignore a parser's output and just execute it\. + +```clojure +(parses parser) +``` + +### parses? + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a .Bit))) +``` + +Ignore a parser's output and just verify that it succeeds\. + +```clojure +(parses? parser) +``` + +### rec + +```clojure +(All (_ a b) (-> (-> (Parser a b) (Parser a b)) (Parser a b))) +``` + +Combinator for recursive parsers\. + +```clojure +(rec parser) +``` + +### remaining + +```clojure +(All (_ a) (Parser a a)) +``` + +Yield the remaining input \(without consuming it\)\. + +### result + +```clojure +(All (_ a b) (-> (Parser a b) a (library/lux/control/try.Try [a b]))) +``` + +Executes the parser on the input\. +Does not verify that all of the input has been consumed by the parser\. +Returns both the parser's output, and a value that represents the remaining input\. + +```clojure +(result parser input) +``` + +### separated\_by + +```clojure +(All (_ a b c) (-> (Parser a c) (Parser a b) (Parser a (.List b)))) +``` + +Parses instances of 'parser' that are separated by instances of 'separator'\. + +```clojure +(separated_by separator parser) +``` + +### some + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a (.List b)))) +``` + +0\-or\-more combinator\. + +```clojure +(some parser) +``` + +### speculative + +```clojure +(All (_ a b) (-> (Parser a b) (Parser a b))) +``` + +Executes a parser, without actually consuming the input\. +That way, the same input can be consumed again by another parser\. + +```clojure +(speculative parser) +``` + +___ + +# library/lux/control/parser/analysis + +## Definitions + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser (.List library/lux/tool/compiler/language/lux/analysis.Analysis)) +``` + +A parser for Lux code analysis nodes\. + +### any + +```clojure +(Parser library/lux/tool/compiler/language/lux/analysis.Analysis) +``` + +Matches any value, without discrimination\. + +### bit + +```clojure +(Parser .Bit) +``` + +Queries for a bit value\. + +### bit\! + +```clojure +(-> .Bit (Parser .Any)) +``` + +Assert a specific bit value\. + +### cannot\_parse + +```clojure +(library/lux/control/exception.Exception (.List library/lux/tool/compiler/language/lux/analysis.Analysis)) +``` + +### constant + +```clojure +(Parser .Name) +``` + +Queries for a constant value\. + +### constant\! + +```clojure +(-> .Name (Parser .Any)) +``` + +Assert a specific constant value\. + +### end\! + +```clojure +(Parser .Any) +``` + +Ensures there are no more inputs\. + +### end? + +```clojure +(Parser .Bit) +``` + +Checks whether there are no more inputs\. + +### foreign + +```clojure +(Parser .Nat) +``` + +Queries for a foreign value\. + +### foreign\! + +```clojure +(-> .Nat (Parser .Any)) +``` + +Assert a specific foreign value\. + +### frac + +```clojure +(Parser .Frac) +``` + +Queries for a frac value\. + +### frac\! + +```clojure +(-> .Frac (Parser .Any)) +``` + +Assert a specific frac value\. + +### int + +```clojure +(Parser .Int) +``` + +Queries for a int value\. + +### int\! + +```clojure +(-> .Int (Parser .Any)) +``` + +Assert a specific int value\. + +### local + +```clojure +(Parser .Nat) +``` + +Queries for a local value\. + +### local\! + +```clojure +(-> .Nat (Parser .Any)) +``` + +Assert a specific local value\. + +### nat + +```clojure +(Parser .Nat) +``` + +Queries for a nat value\. + +### nat\! + +```clojure +(-> .Nat (Parser .Any)) +``` + +Assert a specific nat value\. + +### result + +```clojure +(All (_ a) (-> (Parser a) (.List library/lux/tool/compiler/language/lux/analysis.Analysis) (library/lux/control/try.Try a))) +``` + +Executes a parser and makes sure no inputs go unconsumed\. + +```clojure +(result parser input) +``` + +### rev + +```clojure +(Parser .Rev) +``` + +Queries for a rev value\. + +### rev\! + +```clojure +(-> .Rev (Parser .Any)) +``` + +Assert a specific rev value\. + +### text + +```clojure +(Parser .Text) +``` + +Queries for a text value\. + +### text\! + +```clojure +(-> .Text (Parser .Any)) +``` + +Assert a specific text value\. + +### tuple + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses only within the context of a tuple's contents\. + +```clojure +(tuple parser) +``` + +### unconsumed\_input + +```clojure +(library/lux/control/exception.Exception (.List library/lux/tool/compiler/language/lux/analysis.Analysis)) +``` + +___ + +# library/lux/control/parser/binary + +## Definitions + +### Offset + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +An offset for reading within binary data\. + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser [Offset library/lux/data/binary.Binary]) +``` + +A parser for raw binary data\. + +### Size + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +The size of a chunk of data within a binary array\. + +### any + +```clojure +(Parser .Any) +``` + +Does no parsing, and just returns a dummy value\. + +### binary/16 + +```clojure +(Parser library/lux/data/binary.Binary) +``` + +Parses a block of data prefixed with a size that is 16 bytes long\. + +### binary/32 + +```clojure +(Parser library/lux/data/binary.Binary) +``` + +Parses a block of data prefixed with a size that is 32 bytes long\. + +### binary/64 + +```clojure +(Parser library/lux/data/binary.Binary) +``` + +Parses a block of data prefixed with a size that is 64 bytes long\. + +### binary/8 + +```clojure +(Parser library/lux/data/binary.Binary) +``` + +Parses a block of data prefixed with a size that is 8 bytes long\. + +### binary\_was\_not\_fully\_read + +```clojure +(library/lux/control/exception.Exception [.Nat .Nat]) +``` + +### bit + +```clojure +(Parser .Bit) +``` + +### bits/16 + +```clojure +(Parser .I64) +``` + +### bits/32 + +```clojure +(Parser .I64) +``` + +### bits/64 + +```clojure +(Parser .I64) +``` + +### bits/8 + +```clojure +(Parser .I64) +``` + +### code + +```clojure +(Parser .Code) +``` + +### end? + +```clojure +(Parser .Bit) +``` + +Checks whether there is no more data to read\. + +### frac + +```clojure +(Parser .Frac) +``` + +### int + +```clojure +(Parser .Int) +``` + +### invalid\_tag + +```clojure +(library/lux/control/exception.Exception [.Nat .Nat]) +``` + +### list + +```clojure +(All (_ a) (-> (Parser a) (Parser (.List a)))) +``` + +Parses an arbitrarily long list of values\. + +```clojure +(list value) +``` + +### location + +```clojure +(Parser .Location) +``` + +### maybe + +```clojure +(All (_ a) (-> (Parser a) (Parser (.Maybe a)))) +``` + +### name + +```clojure +(Parser .Name) +``` + +### nat + +```clojure +(Parser .Nat) +``` + +### not\_a\_bit + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### offset + +```clojure +(Parser Offset) +``` + +The current offset \(i\.e\. how much data has been read\)\. + +### or + +```clojure +(All (_ a b) (-> (Parser a) (Parser b) (Parser (Or a b)))) +``` + +### rec + +```clojure +(All (_ a) (-> (-> (Parser a) (Parser a)) (Parser a))) +``` + +Tie the knot for a recursive parser\. + +### remaining + +```clojure +(Parser .Nat) +``` + +How much of the data remains to be read\. + +### result + +```clojure +(All (_ a) (-> (Parser a) library/lux/data/binary.Binary (library/lux/control/try.Try a))) +``` + +Runs a parser and checks that all the binary data was read by it\. + +```clojure +(result parser input) +``` + +### rev + +```clojure +(Parser .Rev) +``` + +### row/16 + +```clojure +(All (_ a) (-> (Parser a) (Parser (library/lux/data/collection/row.Row a)))) +``` + +Parses a row of values prefixed with a size that is 16 bytes long\. + +### row/32 + +```clojure +(All (_ a) (-> (Parser a) (Parser (library/lux/data/collection/row.Row a)))) +``` + +Parses a row of values prefixed with a size that is 32 bytes long\. + +### row/64 + +```clojure +(All (_ a) (-> (Parser a) (Parser (library/lux/data/collection/row.Row a)))) +``` + +Parses a row of values prefixed with a size that is 64 bytes long\. + +### row/8 + +```clojure +(All (_ a) (-> (Parser a) (Parser (library/lux/data/collection/row.Row a)))) +``` + +Parses a row of values prefixed with a size that is 8 bytes long\. + +### segment + +```clojure +(-> .Nat (Parser library/lux/data/binary.Binary)) +``` + +Parses a chunk of data of a given size\. + +```clojure +(segment size) +``` + +### set + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (Parser a) (Parser (library/lux/data/collection/set.Set a)))) +``` + +```clojure +(set hash value) +``` + +### set\_elements\_are\_not\_unique + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### size/16 + +```clojure +Size +``` + +### size/32 + +```clojure +Size +``` + +### size/64 + +```clojure +Size +``` + +### size/8 + +```clojure +Size +``` + +### text + +```clojure +(Parser .Text) +``` + +### type + +```clojure +(Parser .Type) +``` + +### utf8/16 + +```clojure +(Parser .Text) +``` + +Parses a block of \(UTF\-8 encoded\) text prefixed with a size that is 16 bytes long\. + +### utf8/32 + +```clojure +(Parser .Text) +``` + +Parses a block of \(UTF\-8 encoded\) text prefixed with a size that is 32 bytes long\. + +### utf8/64 + +```clojure +(Parser .Text) +``` + +Parses a block of \(UTF\-8 encoded\) text prefixed with a size that is 64 bytes long\. + +### utf8/8 + +```clojure +(Parser .Text) +``` + +Parses a block of \(UTF\-8 encoded\) text prefixed with a size that is 8 bytes long\. + +## Missing documentation + +1. `` or/5 `` + +___ + +# library/lux/control/parser/cli + +## Definitions + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser (.List .Text) it) +``` + +A command\-line interface parser\. + +### any + +```clojure +(Parser .Text) +``` + +Just returns the next input without applying any logic\. + +### end + +```clojure +(Parser .Any) +``` + +Ensures there are no more inputs\. + +### named + +```clojure +(All (_ a) (-> .Text (Parser a) (Parser a))) +``` + +Parses a named parameter and yields its value\. + +```clojure +(named name value) +``` + +### parameter + +```clojure +(All (_ a) (-> [.Text .Text] (Parser a) (Parser a))) +``` + +Parses a parameter that can have either a short or a long name\. + +```clojure +(parameter [short long] value) +``` + +### parse + +```clojure +(All (_ a) (-> (-> .Text (library/lux/control/try.Try a)) (Parser a))) +``` + +Parses the next input with a parsing function\. + +```clojure +(parse parser) +``` + +### result + +```clojure +(All (_ a) (-> (Parser a) (.List .Text) (library/lux/control/try.Try a))) +``` + +Executes the parser and verifies that all inputs are processed\. + +```clojure +(result parser inputs) +``` + +### somewhere + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Given a parser, tries to parse it somewhere in the inputs \(i\.e\. not necessarily parsing the immediate inputs\)\. + +```clojure +(somewhere cli) +``` + +### this + +```clojure +(-> .Text (Parser .Any)) +``` + +Checks that a token is in the inputs\. + +```clojure +(this reference) +``` + +___ + +# library/lux/control/parser/code + +## Definitions + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser (.List .Code)) +``` + +A Lux code parser\. + +### any + +```clojure +(Parser .Code) +``` + +Yields the next input without applying any logic\. + +### bit + +```clojure +(Parser .Bit) +``` + +Parses the next bit input\. + +### bit\! + +```clojure +(-> .Bit (Parser .Any)) +``` + +Checks for a specific bit input\. + +### end\! + +```clojure +(Parser .Any) +``` + +Verifies there are no more inputs\. + +### end? + +```clojure +(Parser .Bit) +``` + +Checks whether there are no more inputs\. + +### form + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a form\. + +### frac + +```clojure +(Parser .Frac) +``` + +Parses the next frac input\. + +### frac\! + +```clojure +(-> .Frac (Parser .Any)) +``` + +Checks for a specific frac input\. + +### identifier + +```clojure +(Parser .Name) +``` + +Parses the next identifier input\. + +### identifier\! + +```clojure +(-> .Name (Parser .Any)) +``` + +Checks for a specific identifier input\. + +### int + +```clojure +(Parser .Int) +``` + +Parses the next int input\. + +### int\! + +```clojure +(-> .Int (Parser .Any)) +``` + +Checks for a specific int input\. + +### local + +```clojure +(All (_ a) (-> (.List .Code) (Parser a) (Parser a))) +``` + +Runs parser against the given list of inputs\. + +```clojure +(local inputs parser) +``` + +### local\_identifier + +```clojure +(Parser .Text) +``` + +Parse a local local identifier \(a local identifier that has no module prefix\)\. + +### local\_identifier\! + +```clojure +(-> .Text (Parser .Any)) +``` + +Checks for a specific local local identifier \(a local identifier that has no module prefix\)\. + +### local\_tag + +```clojure +(Parser .Text) +``` + +Parse a local local tag \(a local tag that has no module prefix\)\. + +### local\_tag\! + +```clojure +(-> .Text (Parser .Any)) +``` + +Checks for a specific local local tag \(a local tag that has no module prefix\)\. + +### nat + +```clojure +(Parser .Nat) +``` + +Parses the next nat input\. + +### nat\! + +```clojure +(-> .Nat (Parser .Any)) +``` + +Checks for a specific nat input\. + +### record + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a record\. + +### result + +```clojure +(All (_ a) (-> (Parser a) (.List .Code) (library/lux/control/try.Try a))) +``` + +Executes a parser against a stream of code, and verifies all the inputs are consumed\. + +```clojure +(result parser inputs) +``` + +### rev + +```clojure +(Parser .Rev) +``` + +Parses the next rev input\. + +### rev\! + +```clojure +(-> .Rev (Parser .Any)) +``` + +Checks for a specific rev input\. + +### tag + +```clojure +(Parser .Name) +``` + +Parses the next tag input\. + +### tag\! + +```clojure +(-> .Name (Parser .Any)) +``` + +Checks for a specific tag input\. + +### text + +```clojure +(Parser .Text) +``` + +Parses the next text input\. + +### text\! + +```clojure +(-> .Text (Parser .Any)) +``` + +Checks for a specific text input\. + +### this\! + +```clojure +(-> .Code (Parser .Any)) +``` + +Ensures the given Code is the next input\. + +```clojure +(this! code) +``` + +### tuple + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a tuple\. + +## Missing documentation + +1. `` next `` +1. `` not `` + +___ + +# library/lux/control/parser/environment + +## Definitions + +### Environment + +```clojure +... .Type +(library/lux/data/collection/dictionary.Dictionary Property .Text) +``` + +An abstraction for environment variables of a program\. + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser Environment it) +``` + +A parser of environment variables of a program\. + +### Property + +```clojure +... .Type +(primitive "#Text") +``` + +A property in the environment\. + +### empty + +```clojure +Environment +``` + +An empty environment\. + +### property + +```clojure +(-> Property (Parser .Text)) +``` + +```clojure +(property name) +``` + +### result + +```clojure +(All (_ a) (-> (Parser a) Environment (library/lux/control/try.Try a))) +``` + +Executes a parser against the given environment variables\. +Does not check whether all environment variables were parsed, since they're usually an open set\. + +```clojure +(result parser environment) +``` + +### unknown\_property + +```clojure +(library/lux/control/exception.Exception Property) +``` + +___ + +# library/lux/control/parser/json + +## Definitions + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser (.List library/lux/data/format/json.JSON) it) +``` + +A JSON parser\. + +### any + +```clojure +(Parser library/lux/data/format/json.JSON) +``` + +Just returns the JSON input without applying any logic\. + +### array + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a JSON array\. + +```clojure +(array parser) +``` + +### boolean + +```clojure +(Parser library/lux/data/format/json.Boolean) +``` + +Reads a JSON value as boolean\. + +### boolean\! + +```clojure +(-> library/lux/data/format/json.Boolean (Parser .Any)) +``` + +Ensures a JSON value is a boolean\. + +```clojure +( + + boolean! test) +``` + +### boolean? + +```clojure +(-> library/lux/data/format/json.Boolean (Parser .Bit)) +``` + +Asks whether a JSON value is a boolean\. + +```clojure + ( + + + + +boolean? test) +``` + +### dictionary + +```clojure +(All (_ a) (-> (Parser a) (Parser (library/lux/data/collection/dictionary.Dictionary .Text a)))) +``` + +Parses a dictionary\-like JSON object\. + +### empty\_input + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### field + +```clojure +(All (_ a) (-> .Text (Parser a) (Parser a))) +``` + +Parses a field inside a JSON object\. +Use this inside the 'object' combinator\. + +```clojure +(field field_name parser) +``` + +### null + +```clojure +(Parser library/lux/data/format/json.Null) +``` + +Reads a JSON value as null\. + +### nullable + +```clojure +(All (_ a) (-> (Parser a) (Parser (.Maybe a)))) +``` + +Enhances parser by adding NULL\-handling\. + +```clojure +(nullable parser) +``` + +### number + +```clojure +(Parser library/lux/data/format/json.Number) +``` + +Reads a JSON value as number\. + +### number\! + +```clojure +(-> library/lux/data/format/json.Number (Parser .Any)) +``` + +Ensures a JSON value is a number\. + +```clojure +( + + + number! test) +``` + +### number? + +```clojure +(-> library/lux/data/format/json.Number (Parser .Bit)) +``` + +Asks whether a JSON value is a number\. + +```clojure + ( + + + + + +number? test) +``` + +### object + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a JSON object\. +Use this with the 'field' combinator\. + +```clojure +(object parser) +``` + +### result + +```clojure +(All (_ a) (-> (Parser a) library/lux/data/format/json.JSON (library/lux/control/try.Try a))) +``` + +Executes the parser against a JSON object\. +Verifies that all of the JSON was consumed by the parser\. + +```clojure +(result parser json) +``` + +### string + +```clojure +(Parser library/lux/data/format/json.String) +``` + +Reads a JSON value as string\. + +### string\! + +```clojure +(-> library/lux/data/format/json.String (Parser .Any)) +``` + +Ensures a JSON value is a string\. + +```clojure +( + + + + string! test) +``` + +### string? + +```clojure +(-> library/lux/data/format/json.String (Parser .Bit)) +``` + +Asks whether a JSON value is a string\. + +```clojure + ( + + + + + + +string? test) +``` + +### unconsumed\_input + +```clojure +(library/lux/control/exception.Exception (.List library/lux/data/format/json.JSON)) +``` + +### unexpected\_value + +```clojure +(library/lux/control/exception.Exception library/lux/data/format/json.JSON) +``` + +### value\_mismatch + +```clojure +(All (_ a) (library/lux/control/exception.Exception [library/lux/data/format/json.JSON library/lux/data/format/json.JSON])) +``` + +___ + +# library/lux/control/parser/synthesis + +## Definitions + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser (.List library/lux/tool/compiler/language/lux/synthesis.Synthesis)) +``` + +A parser for the Lux compiler's synthesis nodes using during optimization\. + +### any + +```clojure +(Parser library/lux/tool/compiler/language/lux/synthesis.Synthesis) +``` + +Yields a synthesis node without subjecting it to any analysis\. + +### bit + +```clojure +(Parser .Bit) +``` + +Queries for a bit synthesis node\. + +### bit\! + +```clojure +(-> .Bit (Parser .Any)) +``` + +Checks for a specific bit synthesis node\. + +```clojure + ( + +bit! expected) +``` + +### cannot\_parse + +```clojure +(library/lux/control/exception.Exception (.List library/lux/tool/compiler/language/lux/synthesis.Synthesis)) +``` + +### constant + +```clojure +(Parser .Name) +``` + +Queries for a constant synthesis node\. + +### constant\! + +```clojure +(-> .Name (Parser .Any)) +``` + +Checks for a specific constant synthesis node\. + +```clojure +( + + + + + + + + constant! expected) +``` + +### empty\_input + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### end\! + +```clojure +(Parser .Any) +``` + +Ensures there are no more inputs\. + +### end? + +```clojure +(Parser .Bit) +``` + +Checks whether there are no more inputs\. + +### expected\_empty\_input + +```clojure +(library/lux/control/exception.Exception (.List library/lux/tool/compiler/language/lux/synthesis.Synthesis)) +``` + +### f64 + +```clojure +(Parser .Frac) +``` + +Queries for a f64 synthesis node\. + +### f64\! + +```clojure +(-> .Frac (Parser .Any)) +``` + +Checks for a specific f64 synthesis node\. + +```clojure + ( + + + +f64! expected) +``` + +### foreign + +```clojure +(Parser .Nat) +``` + +Queries for a foreign synthesis node\. + +### foreign\! + +```clojure +(-> .Nat (Parser .Any)) +``` + +Checks for a specific foreign synthesis node\. + +```clojure +( + + + + + + + foreign! expected) +``` + +### function + +```clojure +(All (_ a) (-> library/lux/tool/compiler/arity.Arity (Parser a) (Parser [(library/lux/tool/compiler/language/lux/analysis.Environment library/lux/tool/compiler/language/lux/synthesis.Synthesis) a]))) +``` + +Parses the body of a function with the 'expected' arity\. + +```clojure +(function expected parser) +``` + +### i64 + +```clojure +(Parser (.I64 .Any)) +``` + +Queries for a i64 synthesis node\. + +### i64\! + +```clojure +(-> (.I64 .Any) (Parser .Any)) +``` + +Checks for a specific i64 synthesis node\. + +```clojure + ( + + +i64! expected) +``` + +### local + +```clojure +(Parser .Nat) +``` + +Queries for a local synthesis node\. + +### local\! + +```clojure +(-> .Nat (Parser .Any)) +``` + +Checks for a specific local synthesis node\. + +```clojure +( + + + + + + local! expected) +``` + +### loop + +```clojure +(All (_ a b) (-> (Parser a) (Parser b) (Parser [library/lux/tool/compiler/reference/variable.Register a b]))) +``` + +Parses the initial values and the body of a loop\. + +```clojure +(loop init_parsers iteration_parser) +``` + +### result + +```clojure +(All (_ a) (-> (Parser a) (.List library/lux/tool/compiler/language/lux/synthesis.Synthesis) (library/lux/control/try.Try a))) +``` + +Executes the parser against the inputs\. +Ensures all inputs are consumed by the parser\. + +```clojure +(result parser input) +``` + +### text + +```clojure +(Parser .Text) +``` + +Queries for a text synthesis node\. + +### text\! + +```clojure +(-> .Text (Parser .Any)) +``` + +Checks for a specific text synthesis node\. + +```clojure +( + + + + +text! expected) +``` + +### tuple + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a tuple\. + +```clojure +(tuple parser) +``` + +### unconsumed\_input + +```clojure +(library/lux/control/exception.Exception (.List library/lux/tool/compiler/language/lux/synthesis.Synthesis)) +``` + +### wrong\_arity + +```clojure +(library/lux/control/exception.Exception [library/lux/tool/compiler/arity.Arity library/lux/tool/compiler/arity.Arity]) +``` + +___ + +# library/lux/control/parser/text + +## Definitions + +### Offset + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +An offset into a block of text\. + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser [Offset .Text]) +``` + +A parser for text\. + +### Slice + +```clojure +... .Type +[Offset Offset] +``` + +A slice of a block of text\. + +### alpha + +```clojure +(Parser .Text) +``` + +Yields alphabetic characters\. + +### alpha\_num + +```clojure +(Parser .Text) +``` + +Yields alphanumeric characters\. + +### and + +```clojure +(-> (Parser .Text) (Parser .Text) (Parser .Text)) +``` + +Yields the outputs of both parsers composed together\. + +```clojure +(and left right) +``` + +### and\! + +```clojure +(-> (Parser Slice) (Parser Slice) (Parser Slice)) +``` + +Yields the outputs of both parsers composed together \(as a slice\)\. + +```clojure +(and! left right) +``` + +### any + +```clojure +(Parser .Text) +``` + +Yields the next character without applying any logic\. + +### any\! + +```clojure +(Parser Slice) +``` + +Yields the next character \(as a slice\) without applying any logic\. + +### at\_least + +```clojure +(-> .Nat (Parser .Text) (Parser .Text)) +``` + +Yields at least N characters\. + +```clojure + ( + + + + + + +at_least amount parser) +``` + +### at\_least\! + +```clojure +(-> .Nat (Parser Slice) (Parser Slice)) +``` + +Yields at least N characters \(as a slice\)\. + +```clojure +( + + + + at_least! amount parser) +``` + +### at\_most + +```clojure +(-> .Nat (Parser .Text) (Parser .Text)) +``` + +Yields at most N characters\. + +```clojure + ( + + + + + +at_most amount parser) +``` + +### at\_most\! + +```clojure +(-> .Nat (Parser Slice) (Parser Slice)) +``` + +Yields at most N characters \(as a slice\)\. + +```clojure +( + + + at_most! amount parser) +``` + +### between + +```clojure +(-> .Nat .Nat (Parser .Text) (Parser .Text)) +``` + +```clojure +(between minimum additional parser) +``` + +### between\! + +```clojure +(-> .Nat .Nat (Parser Slice) (Parser Slice)) +``` + +```clojure +(between! minimum additional parser) +``` + +### cannot\_match + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### cannot\_parse + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### cannot\_slice + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### character\_does\_not\_satisfy\_predicate + +```clojure +(library/lux/control/exception.Exception library/lux/data/text.Char) +``` + +### character\_should\_be + +```clojure +(library/lux/control/exception.Exception [.Text library/lux/data/text.Char]) +``` + +### character\_should\_not\_be + +```clojure +(library/lux/control/exception.Exception [.Text library/lux/data/text.Char]) +``` + +### decimal + +```clojure +(Parser .Text) +``` + +Only yields decimal characters\. + +### enclosed + +```clojure +(All (_ a) (-> [.Text .Text] (Parser a) (Parser a))) +``` + +```clojure +(enclosed [start end] parser) +``` + +### end\! + +```clojure +(Parser .Any) +``` + +Ensure the parser's input is empty\. + +### exactly + +```clojure +(-> .Nat (Parser .Text) (Parser .Text)) +``` + +Yields exactly N characters\. + +```clojure + ( + + + + +exactly amount parser) +``` + +### exactly\! + +```clojure +(-> .Nat (Parser Slice) (Parser Slice)) +``` + +Yields exactly N characters \(as a slice\)\. + +```clojure +( + + exactly! amount parser) +``` + +### expected\_to\_fail + +```clojure +(library/lux/control/exception.Exception [Offset .Text]) +``` + +### hexadecimal + +```clojure +(Parser .Text) +``` + +Yields hexadecimal digits\. + +### local + +```clojure +(All (_ a) (-> .Text (Parser a) (Parser a))) +``` + +Applies a parser against the given input\. + +```clojure +(local local_input parser) +``` + +### lower + +```clojure +(Parser .Text) +``` + +Only yields lowercase characters\. + +### many + +```clojure +(-> (Parser .Text) (Parser .Text)) +``` + +Yields <name> characters as a single continuous text\. + +```clojure + ( + + + + + +many parser) +``` + +### many\! + +```clojure +(-> (Parser Slice) (Parser Slice)) +``` + +Yields <name> characters as a single continuous text \(as a slice\)\. + +```clojure +( + + +many! parser) +``` + +### next + +```clojure +(Parser .Text) +``` + +Yields the next character \(without consuming it from the input\)\. + +### none\_of + +```clojure +(-> .Text (Parser .Text)) +``` + +Yields characters that are not part of a piece of text\. + +```clojure + ( + + +none_of options) +``` + +### none\_of\! + +```clojure +(-> .Text (Parser Slice)) +``` + +Yields characters \(as a slice\) that are not part of a piece of text\. + +```clojure + ( + + +none_of! options) +``` + +### not + +```clojure +(All (_ a) (-> (Parser a) (Parser .Text))) +``` + +Produce a character if the parser fails\. + +```clojure + ( + +not parser) +``` + +### not\! + +```clojure +(All (_ a) (-> (Parser a) (Parser Slice))) +``` + +Produce a character \(as a slice\) if the parser fails\. + +```clojure + ( + + +not! parser) +``` + +### octal + +```clojure +(Parser .Text) +``` + +Only yields octal characters\. + +### offset + +```clojure +(Parser Offset) +``` + +Yields the current offset into the input\. + +### one\_of + +```clojure +(-> .Text (Parser .Text)) +``` + +Yields characters that are part of a piece of text\. + +```clojure + ( + +one_of options) +``` + +### one\_of\! + +```clojure +(-> .Text (Parser Slice)) +``` + +Yields characters \(as a slice\) that are part of a piece of text\. + +```clojure + ( + +one_of! options) +``` + +### range + +```clojure +(-> .Nat .Nat (Parser .Text)) +``` + +Only yields characters within a range\. + +```clojure +(range bottom top) +``` + +### remaining + +```clojure +(Parser .Text) +``` + +Get all of the remaining input \(without consuming it\)\. + +### result + +```clojure +(All (_ a) (-> (Parser a) .Text (library/lux/control/try.Try a))) +``` + +Executes a parser against a block of text\. +Verifies that the entire input has been processed\. + +```clojure +(result parser input) +``` + +### satisfies + +```clojure +(-> (-> library/lux/data/text.Char .Bit) (Parser .Text)) +``` + +Yields characters that satisfy a predicate\. + +```clojure +(satisfies parser) +``` + +### slice + +```clojure +(-> (Parser Slice) (Parser .Text)) +``` + +Converts a slice to a block of text\. + +```clojure +(slice parser) +``` + +### some + +```clojure +(-> (Parser .Text) (Parser .Text)) +``` + +Yields <name> characters as a single continuous text\. + +```clojure + ( + + + + +some parser) +``` + +### some\! + +```clojure +(-> (Parser Slice) (Parser Slice)) +``` + +Yields <name> characters as a single continuous text \(as a slice\)\. + +```clojure +( + +some! parser) +``` + +### space + +```clojure +(Parser .Text) +``` + +Yields white\-space\. + +### then + +```clojure +(All (_ a b) (-> (Parser b) (library/lux/control/parser.Parser a .Text) (library/lux/control/parser.Parser a b))) +``` + +Embeds a text parser into an arbitrary parser that yields text\. + +```clojure +(then structured text) +``` + +### this + +```clojure +(-> .Text (Parser .Any)) +``` + +Checks that a specific text shows up in the input\. + +```clojure +(this reference) +``` + +### unconsumed\_input + +```clojure +(library/lux/control/exception.Exception [Offset .Text]) +``` + +### upper + +```clojure +(Parser .Text) +``` + +Only yields uppercase characters\. + +___ + +# library/lux/control/parser/tree + +## Definitions + +### \(Parser it\) + +```clojure +... .Type +(All (_ b) (library/lux/control/parser.Parser (library/lux/data/collection/tree/zipper.Zipper it) b)) +``` + +A parser of arbitrary trees\. + +### cannot\_move\_further + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### down + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move down\. + +### end + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the last node\. + +### left + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the left\. + +### leftmost + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the leftmost node\. + +### next + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the next node\. + +### previous + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the previous node\. + +### result + +```clojure +(All (_ a b) (-> (Parser a b) (library/lux/data/collection/tree.Tree a) (library/lux/control/try.Try b))) +``` + +Applies the parser against a tree\. + +```clojure +(result parser tree) +``` + +### result' + +```clojure +(All (_ a b) (-> (Parser a b) (library/lux/data/collection/tree/zipper.Zipper a) (library/lux/control/try.Try b))) +``` + +Applies the parser against a tree zipper\. + +```clojure +(result' parser zipper) +``` + +### right + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the right\. + +### rightmost + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the rightmost node\. + +### start + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move to the root node\. + +### up + +```clojure +(All (_ a) (Parser a .Any)) +``` + +Move up\. + +### value + +```clojure +(All (_ a) (Parser a a)) +``` + +Yields the value inside the current tree node\. + +___ + +# library/lux/control/parser/type + +Parsing of Lux types\. +Used mostly for polytypic programming\. + +## Definitions + +### Env + +```clojure +... .Type +(library/lux/data/collection/dictionary.Dictionary .Nat [.Type .Code]) +``` + +An environment for type parsing\. + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser [Env (.List .Type)] it) +``` + +A parser of Lux types\. + +### adjusted\_idx + +```clojure +(-> Env .Nat .Nat) +``` + +```clojure +(adjusted_idx env idx) +``` + +### any + +```clojure +(Parser .Type) +``` + +Yields a type, without examination\. + +### applied + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses a type application\. + +```clojure +(applied poly) +``` + +### empty\_input + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### env + +```clojure +(Parser Env) +``` + +Yields the current parsing environment\. + +### exactly + +```clojure +(-> .Type (Parser .Any)) +``` + +Parses a type exactly\. + +```clojure + ( + +exactly expected) +``` + +### existential + +```clojure +(Parser .Nat) +``` + +Yields an existential type\. + +### fresh + +```clojure +Env +``` + +An empty parsing environment\. + +### function + +```clojure +(All (_ a b) (-> (Parser a) (Parser b) (Parser [a b]))) +``` + +Parses a function's inputs and output\. + +```clojure +(function in_poly out_poly) +``` + +### local + +```clojure +(All (_ a) (-> (.List .Type) (Parser a) (Parser a))) +``` + +Apply a parser to the given inputs\. + +```clojure +(local types poly) +``` + +### named + +```clojure +(Parser [.Name .Type]) +``` + +Yields a named type\. + +### next + +```clojure +(Parser .Type) +``` + +Inspect a type in the input stream without consuming it\. + +### not\_application + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_existential + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_function + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_named + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_parameter + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_polymorphic + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_recursive + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_tuple + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### not\_variant + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### parameter + +```clojure +(Parser .Code) +``` + +### parameter\! + +```clojure +(-> .Nat (Parser .Any)) +``` + +```clojure +(parameter! id) +``` + +### polymorphic + +```clojure +(All (_ a) (-> (Parser a) (Parser [.Code (.List .Code) a]))) +``` + +```clojure +(polymorphic poly) +``` + +### recursive + +```clojure +(All (_ a) (-> (Parser a) (Parser [.Code a]))) +``` + +```clojure +(recursive poly) +``` + +### recursive\_call + +```clojure +(Parser .Code) +``` + +### recursive\_self + +```clojure +(Parser .Code) +``` + +### result + +```clojure +(All (_ a) (-> (Parser a) .Type (library/lux/control/try.Try a))) +``` + +Applies a parser against a type\. +Verifies that the parser fully consumes the type's information\. + +```clojure +(result poly type) +``` + +### sub + +```clojure +(-> .Type (Parser .Any)) +``` + +Parses a sub type\. + +```clojure + ( + + +sub expected) +``` + +### super + +```clojure +(-> .Type (Parser .Any)) +``` + +Parses a super type\. + +```clojure + ( + + + +super expected) +``` + +### tuple + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a tuple type\. + +```clojure + ( + + +tuple poly) +``` + +### types\_do\_not\_match + +```clojure +(library/lux/control/exception.Exception [.Type .Type]) +``` + +### unconsumed\_input + +```clojure +(library/lux/control/exception.Exception (.List .Type)) +``` + +### unknown\_parameter + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### variant + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Parses the contents of a variant type\. + +```clojure + ( + +variant poly) +``` + +### with\_extension + +```clojure +(All (_ a) (-> .Type (Parser a) (Parser [.Code a]))) +``` + +```clojure +(with_extension type poly) +``` + +### wrong\_parameter + +```clojure +(library/lux/control/exception.Exception [.Type .Type]) +``` + +___ + +# library/lux/control/parser/xml + +## Definitions + +### \(Parser it\) + +```clojure +... .Type +(library/lux/control/parser.Parser [library/lux/data/format/xml.Attrs (.List library/lux/data/format/xml.XML)] it) +``` + +A parser of XML\-encoded data\. + +### any + +```clojure +(Parser library/lux/data/format/xml.XML) +``` + +Yields the next node\. + +### attribute + +```clojure +(-> library/lux/data/format/xml.Attribute (Parser .Text)) +``` + +Yields the value of an attribute in the current node\. + +```clojure +(attribute name) +``` + +### empty\_input + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### node + +```clojure +(All (_ a) (-> library/lux/data/format/xml.Tag (Parser a) (Parser a))) +``` + +Parses the contents of the next node if the tag matches\. + +```clojure +(node expected parser) +``` + +### nowhere + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### result + +```clojure +(All (_ a) (-> (Parser a) (.List library/lux/data/format/xml.XML) (library/lux/control/try.Try a))) +``` + +Applies a parser against a stream of XML documents\. +Verifies that all of the inputs are consumed by the parser\. + +```clojure +(result parser documents) +``` + +### somewhere + +```clojure +(All (_ a) (-> (Parser a) (Parser a))) +``` + +Applies the parser somewhere among the remaining inputs; instead of demanding that the parser succeeds against the immediate inputs\. + +```clojure +(somewhere parser) +``` + +### tag + +```clojure +(Parser library/lux/data/format/xml.Tag) +``` + +Yields the tag from the next node\. + +### text + +```clojure +(Parser .Text) +``` + +Yields text from a text node\. + +### unconsumed\_inputs + +```clojure +(library/lux/control/exception.Exception (.List library/lux/data/format/xml.XML)) +``` + +### unexpected\_input + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### unknown\_attribute + +```clojure +(library/lux/control/exception.Exception [library/lux/data/format/xml.Attribute (.List library/lux/data/format/xml.Attribute)]) +``` + +### wrong\_tag + +```clojure +(library/lux/control/exception.Exception [library/lux/data/format/xml.Tag library/lux/data/format/xml.Tag]) +``` + +___ + +# library/lux/control/pipe + +Composable extensions to the piping macros \(|> and <|\) that enhance them with various abilities\. + +## Definitions + +### case> + +```clojure +.Macro +``` + +Pattern\-matching for pipes\. +The bodies of each branch are NOT pipes; just regular values\. + +```clojure +(|> +5 + (case> +0 "zero" + +1 "one" + +2 "two" + +3 "three" + +4 "four" + +5 "five" + +6 "six" + +7 "seven" + +8 "eight" + +9 "nine" + _ "???")) +``` + +### cond> + +```clojure +.Macro +``` + +Branching for pipes\. +Both the tests and the bodies are piped\-code, and must be given inside a tuple\. + +```clojure +(|> +5 + (cond> [i.even?] [(i.* +2)] + [i.odd?] [(i.* +3)] + [(new> -1 [])])) +``` + +### do> + +```clojure +.Macro +``` + +Monadic pipes\. +Each steps in the monadic computation is a pipe and must be given inside a tuple\. + +```clojure +(|> +5 + (do> identity.monad + [(i.* +3)] + [(i.+ +4)] + [++])) +``` + +### exec> + +```clojure +.Macro +``` + +Non\-updating pipes\. +Will generate piped computations, but their results will not be used in the larger scope\. + +```clojure +(|> +5 + (exec> [.nat%n log!]) + (i.* +10)) +``` + +### if> + +```clojure +.Macro +``` + +If\-branching\. + +```clojure +(same? (if (n.even? sample) + "even" + "odd") + (|> sample + (if> [n.even?] + [(new> "even" [])] + [(new> "odd" [])]))) +``` + +### let> + +```clojure +.Macro +``` + +Gives a name to the piped\-argument, within the given expression\. + +```clojure +(n.= 10 + (|> 5 + (let> x (n.+ x x)))) +``` + +### loop> + +```clojure +.Macro +``` + +Loops for pipes\. +Both the testing and calculating steps are pipes and must be given inside tuples\. + +```clojure +(|> +1 + (loop> [(i.< +10)] + [++])) +``` + +### new> + +```clojure +.Macro +``` + +Ignores the piped argument, and begins a new pipe\. + +```clojure +(n.= 1 + (|> 20 + (n.* 3) + (n.+ 4) + (new> 0 [++]))) +``` + +### tuple> + +```clojure +.Macro +``` + +Parallel branching for pipes\. +Allows to run multiple pipelines for a value and gives you a tuple of the outputs\. + +```clojure +(|> +5 + (tuple> [(i.* +10)] + [-- (i./ +2)] + [i\encoded])) + +... => + +[+50 +2 "+5"] +``` + +### when> + +```clojure +.Macro +``` + +Only execute the body when the test passes\. + +```clojure +(same? (if (n.even? sample) + (n.* 2 sample) + sample) + (|> sample + (when> [n.even?] + [(n.* 2)]))) +``` + +___ + +# library/lux/control/reader + +## Definitions + +### \(Reader environment it\) + +```clojure +... .Type +(-> environment it) +``` + +Computations that have access to some environmental value\. + +### apply + +```clojure +(All (_ a) (library/lux/abstract/apply.Apply (Reader a))) +``` + +### functor + +```clojure +(All (_ a) (library/lux/abstract/functor.Functor (Reader a))) +``` + +### lifted + +```clojure +(All (_ a b c) (-> (a c) (Reader b (a c)))) +``` + +Lift monadic values to the Reader wrapper\. + +### local + +```clojure +(All (_ a b) (-> (-> a a) (Reader a b) (Reader a b))) +``` + +Run computation with a locally\-modified environment\. + +```clojure +(local change proc) +``` + +### monad + +```clojure +(All (_ a) (library/lux/abstract/monad.Monad (Reader a))) +``` + +### read + +```clojure +(All (_ a) (Reader a a)) +``` + +Get the environment\. + +### result + +```clojure +(All (_ a b) (-> a (Reader a b) b)) +``` + +Executes the reader against the given environment\. + +```clojure +(result env proc) +``` + +### with + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (All (_ b) (library/lux/abstract/monad.Monad (All (_ c) (Reader b (a c))))))) +``` + +Monad transformer for Reader\. + +```clojure +(with monad) +``` + +___ + +# library/lux/control/region + +## Definitions + +### \(Region r \! it\) + +```clojure +... .Type +(-> [r (.List (Cleaner r !))] (! [(.List (Cleaner r !)) (library/lux/control/try.Try it)])) +``` + +A region where resources may be be claimed and where a side\-effecting computation may be performed\. +Every resource is paired with a function that knows how to clean/reclaim it, to make sure there are no leaks\. + +### acquire\! + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (-> b (a (library/lux/control/try.Try .Any))) b (All (_ c) (Region c a b)))) +``` + +Acquire a resource while pairing it a function that knows how to reclaim it\. + +```clojure +(acquire! monad cleaner value) +``` + +### apply + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (All (_ b) (library/lux/abstract/apply.Apply (Region b a))))) +``` + +### clean\_up\_error + +```clojure +(All (_ a) (library/lux/control/exception.Exception [.Text (library/lux/control/try.Try a)])) +``` + +### except + +```clojure +(All (_ a b c) (-> (library/lux/abstract/monad.Monad a) (library/lux/control/exception.Exception b) b (All (_ d) (Region d a c)))) +``` + +Fail by throwing/raising an exception\. + +```clojure +(except monad exception message) +``` + +### failure + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) .Text (All (_ c) (Region c a b)))) +``` + +Immediately fail with this 'message'\. + +```clojure +(failure monad error) +``` + +### functor + +```clojure +(All (_ a) (-> (library/lux/abstract/functor.Functor a) (All (_ b) (library/lux/abstract/functor.Functor (Region b a))))) +``` + +### lifted + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (a b) (All (_ c) (Region c a b)))) +``` + +Lift an effectful computation into a region\-based computation\. + +```clojure +(lifted monad operation) +``` + +### monad + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (All (_ b) (library/lux/abstract/monad.Monad (Region b a))))) +``` + +### run\! + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (All (_ c) (Region c a b)) (a (library/lux/control/try.Try b)))) +``` + +Executes a region\-based computation, with a side\-effect determined by the monad\. + +```clojure +(run! monad computation) +``` + +___ + +# library/lux/control/remember + +## Definitions + +### fix\_me + +```clojure +.Macro +``` + +A FIXME message with an expiration date\. +Can have an optional piece of code to focus on\. + +```clojure + (fix_me + + + + + + + + + + + + + + + + + + "2022-04-01" + "Do this, that and the other.") + +................................................................ +................................................................ + + (fix_me + + + + + + + + + + + + + + + + + + + + + "2022-04-01" + "Improve the performace." + (some (complicated (computation 123)))) +``` + +### must\_remember + +```clojure +(library/lux/control/exception.Exception [library/lux/time/date.Date library/lux/time/date.Date .Text (.Maybe .Code)]) +``` + +### remember + +```clojure +.Macro +``` + +A message with an expiration date\. +Can have an optional piece of code to focus on\. + +```clojure + (remember + + + + + + + + + + + + + + + + + + "2022-04-01" + "Do this, that and the other.") + +................................................................ +................................................................ + + (remember + + + + + + + + + + + + + + + + + + + + + "2022-04-01" + "Improve the performace." + (some (complicated (computation 123)))) +``` + +### to\_do + +```clojure +.Macro +``` + +A TODO message with an expiration date\. +Can have an optional piece of code to focus on\. + +```clojure + (to_do + + + + + + + + + + + + + + + + + + "2022-04-01" + "Do this, that and the other.") + +................................................................ +................................................................ + + (to_do + + + + + + + + + + + + + + + + + + + + + "2022-04-01" + "Improve the performace." + (some (complicated (computation 123)))) +``` + +___ + +# library/lux/control/security/capability + +## Definitions + +### \(Capability brand input output\) + +```clojure +... .Type +(primitive "library/lux/control/security/capability.Capability" brand input output) +``` + +Represents the capability to perform an operation\. +This operation is assumed to have security implications\. + +### async + +```clojure +(All (_ a b c) (-> (Capability a b (library/lux/control/io.IO c)) (Capability a b (library/lux/control/concurrency/async.Async c)))) +``` + +Converts a synchronous I/O\-based capability into an asynchronous capability\. + +```clojure +(async capability) +``` + +### capability: + +```clojure +.Macro +``` + +Defines a capability as a unique type, and a constructor for instances\. + +```clojure +(capability: (Can_Duplicate a) + (can_duplicate a [a a])) + +(let [capability (can_duplicate + (function (_ value) + [value value])) + [left right] (documentation/lux/control/security/capability.usecapability 123)] + (same? left right)) +``` + +### use + +```clojure +(All (_ a b c) (-> (Capability a b c) b c)) +``` + +Applies a capability against its required input\. + +```clojure +(use capability input) +``` + +___ + +# library/lux/control/security/policy + +## Definitions + +### Can\_Conceal + +```clojure +... .Type +(Can_Upgrade Privacy) +``` + +### Can\_Distrust + +```clojure +... .Type +(Can_Downgrade Safety) +``` + +### \(Can\_Downgrade brand % value\) + +```clojure +... .Type +(-> (Policy brand value %) value) +``` + +Represents the capacity to 'downgrade' a value\. + +### Can\_Reveal + +```clojure +... .Type +(Can_Downgrade Privacy) +``` + +### Can\_Trust + +```clojure +... .Type +(Can_Upgrade Safety) +``` + +### \(Can\_Upgrade brand % value\) + +```clojure +... .Type +(-> value (Policy brand value %)) +``` + +Represents the capacity to 'upgrade' a value\. + +### \(Context brand scope %\) + +```clojure +... .Type +(-> (Privilege brand %) (scope %)) +``` + +A computational context with an associated policy privilege\. + +### \(Delegation brand %from %to\) + +```clojure +... .Type +(All (_ d) (-> (Policy brand d %from) (Policy brand d %to))) +``` + +Represents the act of delegating policy capacities\. + +### \(Policy brand value %\) + +```clojure +... .Type +(primitive "library/lux/control/security/policy.Policy" brand value %) +``` + +A security policy encoded as the means to 'upgrade' or 'downgrade' in a secure context\. + +### Privacy + +```clojure +... .Type +(primitive "library/lux/control/security/policy.Privacy") +``` + +A security context for privacy\. +Private data is data which cannot be allowed to leak outside of the programmed\. + +### Private + +```clojure +... .Type +(Policy Privacy) +``` + +### \(Privilege brand %\) + +```clojure +... .Type +[(Can_Upgrade brand %) (Can_Downgrade brand %)] +``` + +Represents the privilege to both 'upgrade' and 'downgrade' a value\. + +### Safe + +```clojure +... .Type +(Policy Safety) +``` + +### Safety + +```clojure +... .Type +(primitive "library/lux/control/security/policy.Safety") +``` + +A security context for safety\. +Safe data is data coming from outside the program which can be trusted to be properly formatted and lacking injections\. + +### apply + +```clojure +(All (_ a b) (library/lux/abstract/apply.Apply (All (_ c) (Policy a c b)))) +``` + +### delegation + +```clojure +(All (_ a b c) (-> (Can_Downgrade a b) (Can_Upgrade a c) (Delegation a b c))) +``` + +Delegating policy capacities\. + +```clojure +(delegation downgrade upgrade) +``` + +### functor + +```clojure +(All (_ a b) (library/lux/abstract/functor.Functor (All (_ c) (Policy a c b)))) +``` + +### monad + +```clojure +(All (_ a b) (library/lux/abstract/monad.Monad (All (_ c) (Policy a c b)))) +``` + +### with\_policy + +```clojure +(All (_ a b) (Ex (_ c) (-> (Context a b c) (b c)))) +``` + +Activates a security context with the priviledge to enforce it's policy\. + +```clojure +(type: Password + (Private Text)) + +(type: (Policy %) + (Interface + (: (-> Text (Password %)) + password) + (: (-> (Password %) Text) + unsafe))) + +(def: (policy _) + (Ex (_ %) (-> Any (Policy %))) + (with_policy + (: (Context Privacy Policy) + (function (_ (^open "%::.")) + (implementation + (def: (password value) + (%::can_upgrade value)) + (def: (unsafe password) + (%::can_downgrade password))))))) + +................................................................ +................................................................ + +(with_policy context) +``` + +___ + +# library/lux/control/state + +## Definitions + +### \+State + +```clojure +... .Type +(All (+State a b c) (-> b (a [b c]))) +``` + +Stateful computations decorated by a monad\. + +### \(State state it\) + +```clojure +... .Type +(-> state [state it]) +``` + +Stateful computations\. + +### apply + +```clojure +(All (_ a) (library/lux/abstract/apply.Apply (State a))) +``` + +### do\_while + +```clojure +(All (_ a) (-> (State a .Bit) (State a .Any) (State a .Any))) +``` + +A stateful do\-while loop\. + +```clojure +(do_while condition body) +``` + +### functor + +```clojure +(All (_ a) (library/lux/abstract/functor.Functor (State a))) +``` + +### get + +```clojure +(All (_ a) (State a a)) +``` + +Read the current state\. + +### lifted + +```clojure +(All (_ a b c) (-> (library/lux/abstract/monad.Monad a) (a c) (+State a b c))) +``` + +Lift monadic values to the \+State wrapper\. + +```clojure +(lifted monad ma) +``` + +### local + +```clojure +(All (_ a b) (-> (-> a a) (State a b) (State a b))) +``` + +Run the computation with a locally\-modified state\. + +```clojure +(local change action) +``` + +### monad + +```clojure +(All (_ a) (library/lux/abstract/monad.Monad (State a))) +``` + +### put + +```clojure +(All (_ a) (-> a (State a .Any))) +``` + +Set the new state\. + +```clojure +(put new_state) +``` + +### result + +```clojure +(All (_ a b) (-> a (State a b) [a b])) +``` + +Run a stateful computation\. + +```clojure +(result state action) +``` + +### result' + +```clojure +(All (_ a b c) (-> b (+State a b c) (a [b c]))) +``` + +Execute a stateful computation decorated by a monad\. + +```clojure +(result' state action) +``` + +### update + +```clojure +(All (_ a) (-> (-> a a) (State a .Any))) +``` + +Compute the new state\. + +```clojure +(update change) +``` + +### use + +```clojure +(All (_ a b) (-> (-> a b) (State a b))) +``` + +Run a function on the current state\. + +```clojure +(use user) +``` + +### while + +```clojure +(All (_ a) (-> (State a .Bit) (State a .Any) (State a .Any))) +``` + +A stateful while loop\. + +```clojure +(while condition body) +``` + +### with + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (library/lux/abstract/monad.Monad (+State a b)))) +``` + +A monad transformer to create composite stateful computations\. + +```clojure +(with monad) +``` + +___ + +# library/lux/control/thread + +## Definitions + +### \(Box \! it\) + +```clojure +... .Type +(primitive "library/lux/control/thread.Box" ! it) +``` + +A mutable box holding a value\. + +### \(Thread \! it\) + +```clojure +... .Type +(-> ! it) +``` + +An imperative process with access to mutable values\. + +### apply + +```clojure +(All (_ a) (library/lux/abstract/apply.Apply (Thread a))) +``` + +### box + +```clojure +(All (_ a) (-> a (All (_ b) (Thread b (Box b a))))) +``` + +A brand\-new box initialized to the given value\. + +```clojure +(box init) +``` + +### functor + +```clojure +(All (_ a) (library/lux/abstract/functor.Functor (Thread a))) +``` + +### io + +```clojure +(All (_ a) (-> (All (_ b) (Thread b a)) (library/lux/control/io.IO a))) +``` + +Transforms the imperative thread into an I/O computation\. + +### monad + +```clojure +(All (_ a) (library/lux/abstract/monad.Monad (Thread a))) +``` + +### read\! + +```clojure +(All (_ a b) (-> (Box a b) (Thread a b))) +``` + +Reads the current value in the box\. + +```clojure +(read! box) +``` + +### result + +```clojure +(All (_ a) (-> (All (_ b) (Thread b a)) a)) +``` + +Executes the imperative thread in a self\-contained way\. + +```clojure +(result thread) +``` + +### update\! + +```clojure +(All (_ a b) (-> (-> a a) (Box b a) (Thread b a))) +``` + +Update a box's value by applying a function to it\. + +```clojure +(update! f box) +``` + +### write\! + +```clojure +(All (_ a) (-> a (All (_ b) (-> (Box b a) (Thread b .Any))))) +``` + +Mutates the value in the box\. + +```clojure +(write! value box) +``` + +___ + +# library/lux/control/try + +## Definitions + +### \(Try it\) + +```clojure +... .Type +(Or .Text it) +``` + +A computation that can fail with an error message\. + +### apply + +```clojure +(library/lux/abstract/apply.Apply Try) +``` + +### else + +```clojure +.Macro +``` + +Allows you to provide a default value that will be used +if a \(Try x\) value turns out to be \#Failure\. +Note: the expression for the default value will not be computed if the base computation succeeds\. + +```clojure +(= "bar" + (else "foo" (#documentation/lux/control/try.Success"bar"))) + +................................................................ +................................................................ + +(= "foo" + (else "foo" (#documentation/lux/control/try.Failure"KABOOM!"))) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Try a)))) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Try) +``` + +### lifted + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (a b) (a (Try b)))) +``` + +Wraps a monadic value with error\-handling machinery\. + +```clojure +(lifted monad) +``` + +### maybe + +```clojure +(All (_ a) (-> (Try a) (.Maybe a))) +``` + +```clojure +(maybe try) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Try) +``` + +### of\_maybe + +```clojure +(All (_ a) (-> (.Maybe a) (Try a))) +``` + +```clojure +(of_maybe maybe) +``` + +### trusted + +```clojure +(All (_ a) (-> (Try a) a)) +``` + +Assumes a Try value succeeded, and yields its value\. +If it didn't, raises the error as a runtime error\. +WARNING: Use with caution\. + +```clojure +(trusted try) +``` + +### with + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (library/lux/abstract/monad.Monad (All (_ b) (a (Try b)))))) +``` + +Enhances a monad with error\-handling functionality\. + +```clojure +(with monad) +``` + +___ + +# library/lux/control/writer + +## Definitions + +### \(Writer log value\) + +```clojure +... .Type +[log value] +``` + +Represents a value with an associated 'log' to record arbitrary information\. + +### apply + +```clojure +(All (_ a) (-> (library/lux/abstract/monoid.Monoid a) (library/lux/abstract/apply.Apply (Writer a)))) +``` + +### functor + +```clojure +(All (_ a) (library/lux/abstract/functor.Functor (Writer a))) +``` + +### lifted + +```clojure +(All (_ a b c) (-> (library/lux/abstract/monoid.Monoid a) (library/lux/abstract/monad.Monad b) (b c) (b (Writer a c)))) +``` + +Wraps a monadic value with Writer machinery\. + +```clojure +(lifted monoid monad) +``` + +### monad + +```clojure +(All (_ a) (-> (library/lux/abstract/monoid.Monoid a) (library/lux/abstract/monad.Monad (Writer a)))) +``` + +### with + +```clojure +(All (_ a b) (-> (library/lux/abstract/monoid.Monoid a) (library/lux/abstract/monad.Monad b) (library/lux/abstract/monad.Monad (All (_ c) (b (Writer a c)))))) +``` + +Enhances a monad with Writer functionality\. + +```clojure +(with monoid monad) +``` + +### write + +```clojure +(All (_ a) (-> a (Writer a .Any))) +``` + +Write a value to the log\. + +```clojure +(write message) +``` + +___ + +# library/lux/data/binary + +## Definitions + +### Binary + +```clojure +... .Type +(primitive "[B") +``` + +A binary BLOB of data\. + +### after + +```clojure +(-> .Nat Binary Binary) +``` + +Yields a binary BLOB with at most the specified number of bytes removed\. + +```clojure +(after bytes binary) +``` + +### aggregate + +```clojure +(All (_ a) (-> (-> .I64 a a) a Binary a)) +``` + +```clojure +(aggregate f init binary) +``` + +### copy + +```clojure +(-> .Nat .Nat Binary .Nat Binary (library/lux/control/try.Try Binary)) +``` + +Mutates the target binary BLOB by copying bytes from the source BLOB to it\. + +```clojure +(copy bytes source_offset source target_offset target) +``` + +### empty + +```clojure +(-> .Nat Binary) +``` + +A fresh/empty binary BLOB of the specified size\. + +```clojure +(empty size) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Binary) +``` + +### index\_out\_of\_bounds + +```clojure +(library/lux/control/exception.Exception [.Nat .Nat]) +``` + +### monoid + +```clojure +(library/lux/abstract/monoid.Monoid Binary) +``` + +### read/16\! + +```clojure +(-> .Nat Binary (library/lux/control/try.Try .I64)) +``` + +Read 2 bytes \(16 bits\) at the given index\. + +```clojure +(read/16! index binary) +``` + +### read/32\! + +```clojure +(-> .Nat Binary (library/lux/control/try.Try .I64)) +``` + +Read 4 bytes \(32 bits\) at the given index\. + +```clojure +(read/32! index binary) +``` + +### read/64\! + +```clojure +(-> .Nat Binary (library/lux/control/try.Try .I64)) +``` + +Read 8 bytes \(64 bits\) at the given index\. + +```clojure +(read/64! index binary) +``` + +### read/8\! + +```clojure +(-> .Nat Binary (library/lux/control/try.Try .I64)) +``` + +Read 1 byte \(8 bits\) at the given index\. + +```clojure +(read/8! index binary) +``` + +### size + +```clojure +(-> Binary .Nat) +``` + +### slice + +```clojure +(-> .Nat .Nat Binary (library/lux/control/try.Try Binary)) +``` + +Yields a subset of the binary BLOB, so long as the specified range is valid\. + +```clojure +(slice offset length binary) +``` + +### slice\_out\_of\_bounds + +```clojure +(library/lux/control/exception.Exception [.Nat .Nat .Nat]) +``` + +### write/16\! + +```clojure +(-> .Nat (.I64 .Any) Binary (library/lux/control/try.Try Binary)) +``` + +Write 2 bytes \(16 bits\) at the given index\. + +```clojure +(write/16! index value binary) +``` + +### write/32\! + +```clojure +(-> .Nat (.I64 .Any) Binary (library/lux/control/try.Try Binary)) +``` + +Write 4 bytes \(32 bits\) at the given index\. + +```clojure +(write/32! index value binary) +``` + +### write/64\! + +```clojure +(-> .Nat (.I64 .Any) Binary (library/lux/control/try.Try Binary)) +``` + +Write 8 bytes \(64 bits\) at the given index\. + +```clojure +(write/64! index value binary) +``` + +### write/8\! + +```clojure +(-> .Nat (.I64 .Any) Binary (library/lux/control/try.Try Binary)) +``` + +Write 1 byte \(8 bits\) at the given index\. + +```clojure +(write/8! index value binary) +``` + +___ + +# library/lux/data/bit + +## Definitions + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text .Bit) +``` + +### complement + +```clojure +(All (_ a) (-> (-> a .Bit) a .Bit)) +``` + +Generates the complement of a predicate\. +That is a predicate that returns the oposite of the original predicate\. + +### conjunction + +```clojure +(library/lux/abstract/monoid.Monoid .Bit) +``` + +### disjunction + +```clojure +(library/lux/abstract/monoid.Monoid .Bit) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Bit) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash .Bit) +``` + +### no + +```clojure +.Bit +``` + +### off + +```clojure +.Bit +``` + +### on + +```clojure +.Bit +``` + +### yes + +```clojure +.Bit +``` + +___ + +# library/lux/data/collection/array + +## Definitions + +### \(Array it\) + +```clojure +... .Type +(primitive "#Array" it) +``` + +Mutable arrays\. + +### any? + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (library/lux/abstract/predicate.Predicate (Array a)))) +``` + +### clone + +```clojure +(All (_ a) (-> (Array a) (Array a))) +``` + +Yields a shallow clone of the array\. + +```clojure +(clone xs) +``` + +### contains? + +```clojure +(All (_ a) (-> .Nat (Array a) .Bit)) +``` + +```clojure +(contains? index array) +``` + +### copy\! + +```clojure +(All (_ a) (-> .Nat .Nat (Array a) .Nat (Array a) (Array a))) +``` + +Writes the contents of one array into the other\. + +```clojure +(copy! length src_start src_array dest_start dest_array) +``` + +### delete\! + +```clojure +(All (_ a) (-> .Nat (Array a) (Array a))) +``` + +Mutate the array by deleting the value at the specified index\. + +```clojure +(delete! index array) +``` + +### empty + +```clojure +(All (_ a) (-> .Nat (Array a))) +``` + +An empty array of the specified size\. + +```clojure +(empty size) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Array a)))) +``` + +### every? + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (library/lux/abstract/predicate.Predicate (Array a)))) +``` + +### example + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (Array a) (.Maybe a))) +``` + +Yields the first item in the array that satisfies the predicate\. + +```clojure +(example p xs) +``` + +### example\+ + +```clojure +(All (_ a) (-> (-> .Nat a .Bit) (Array a) (.Maybe [.Nat a]))) +``` + +Just like 'example', but with access to the index of each value\. + +```clojure +(example+ p xs) +``` + +### filter\! + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (Array a) (Array a))) +``` + +Delete every item of the array that fails to satisfy the predicate\. + +```clojure +(filter! p xs) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Array) +``` + +### list + +```clojure +(All (_ a) (-> (.Maybe a) (Array a) (.List a))) +``` + +Yields a list with every non\-empty item in the array\. +Can use the optional default value when encountering an empty cell in the array\. + +```clojure +(list #library/lux.Nonearray) + +(list (#library/lux.Somedefault) array) +``` + +### mix + +```clojure +(library/lux/abstract/mix.Mix Array) +``` + +### monoid + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (Array a))) +``` + +### occupancy + +```clojure +(All (_ a) (-> (Array a) .Nat)) +``` + +Finds out how many cells in an array are occupied\. + +```clojure +(occupancy array) +``` + +### of\_list + +```clojure +(All (_ a) (-> (.List a) (Array a))) +``` + +```clojure +(of_list xs) +``` + +### read\! + +```clojure +(All (_ a) (-> .Nat (Array a) (.Maybe a))) +``` + +```clojure +(read! index array) +``` + +### size + +```clojure +(All (_ a) (-> (Array a) .Nat)) +``` + +```clojure +(size array) +``` + +### type\_name + +```clojure +.Text +``` + +### update\! + +```clojure +(All (_ a) (-> .Nat (-> a a) (Array a) (Array a))) +``` + +Mutate the array by updating the value at the specified index\. + +```clojure +(update! index transform array) +``` + +### upsert\! + +```clojure +(All (_ a) (-> .Nat a (-> a a) (Array a) (Array a))) +``` + +Mutate the array by updating the value at the specified index\. +If there is no value, update and write the default value given\. + +```clojure +(upsert! index default transform array) +``` + +### vacancy + +```clojure +(All (_ a) (-> (Array a) .Nat)) +``` + +Finds out how many cells in an array are vacant\. + +```clojure +(vacancy array) +``` + +### write\! + +```clojure +(All (_ a) (-> .Nat a (Array a) (Array a))) +``` + +Mutate the array by writing a value to the specified index\. + +```clojure +(write! index value array) +``` + +___ + +# library/lux/data/collection/bits + +## Definitions + +### Bits + +```clojure +... .Type +(library/lux/data/collection/array.Array Chunk) +``` + +A bit\-map\. + +### Chunk + +```clojure +... .Type +(All (Chunk a) (primitive "#I64" a)) +``` + +### and + +```clojure +(-> Bits Bits Bits) +``` + +```clojure + ( + +and param subject) +``` + +### bit + +```clojure +(-> .Nat Bits .Bit) +``` + +```clojure +(bit index bits) +``` + +### capacity + +```clojure +(-> Bits .Nat) +``` + +```clojure +(capacity bits) +``` + +### chunk\_size + +```clojure +.Nat +``` + +### empty + +```clojure +Bits +``` + +### empty? + +```clojure +(-> Bits .Bit) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Bits) +``` + +### flipped + +```clojure +(-> .Nat Bits Bits) +``` + +```clojure + ( + + + +flipped index input) +``` + +### intersects? + +```clojure +(-> Bits Bits .Bit) +``` + +```clojure +(intersects? reference sample) +``` + +### not + +```clojure +(-> Bits Bits) +``` + +```clojure +(not input) +``` + +### one + +```clojure +(-> .Nat Bits Bits) +``` + +```clojure + ( + +one index input) +``` + +### or + +```clojure +(-> Bits Bits Bits) +``` + +```clojure + ( + + +or param subject) +``` + +### size + +```clojure +(-> Bits .Nat) +``` + +Measures the size of a bit\-map by counting all the 1s in the bit\-map\. + +```clojure +(size bits) +``` + +### xor + +```clojure +(-> Bits Bits Bits) +``` + +```clojure + ( + + + +xor param subject) +``` + +### zero + +```clojure +(-> .Nat Bits Bits) +``` + +```clojure + ( + + +zero index input) +``` + +___ + +# library/lux/data/collection/dictionary + +## Definitions + +### \(Dictionary key value\) + +```clojure +... .Type +[(library/lux/abstract/hash.Hash key) (Node key value)] +``` + +A dictionary implemented as a Hash\-Array Mapped Trie \(HAMT\)\. + +### empty + +```clojure +(All (_ a b) (-> (library/lux/abstract/hash.Hash a) (Dictionary a b))) +``` + +An empty dictionary\. + +```clojure +(empty key_hash) +``` + +### empty? + +```clojure +(All (_ a b) (-> (Dictionary a b) .Bit)) +``` + +### entries + +```clojure +(All (_ a b) (-> (Dictionary a b) (.List [a b]))) +``` + +### equivalence + +```clojure +(All (_ a b) (-> (library/lux/abstract/equivalence.Equivalence b) (library/lux/abstract/equivalence.Equivalence (Dictionary a b)))) +``` + +### functor + +```clojure +(All (_ a) (library/lux/abstract/functor.Functor (Dictionary a))) +``` + +### has + +```clojure +(All (_ a b) (-> a b (Dictionary a b) (Dictionary a b))) +``` + +```clojure +(has key val dict) +``` + +### has' + +```clojure +(All (_ a b) (-> a b (Dictionary a b) (library/lux/control/try.Try (Dictionary a b)))) +``` + +Only puts the KV\-pair if the key is not already present\. + +```clojure +(has' key val dict) +``` + +### key? + +```clojure +(All (_ a b) (-> (Dictionary a b) a .Bit)) +``` + +```clojure +(key? dict key) +``` + +### key\_already\_exists + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### key\_hash + +```clojure +(All (_ a b) (-> (Dictionary a b) (library/lux/abstract/hash.Hash a))) +``` + +### keys + +```clojure +(All (_ a b) (-> (Dictionary a b) (.List a))) +``` + +### lacks + +```clojure +(All (_ a b) (-> a (Dictionary a b) (Dictionary a b))) +``` + +```clojure +(lacks key dict) +``` + +### merged + +```clojure +(All (_ a b) (-> (Dictionary a b) (Dictionary a b) (Dictionary a b))) +``` + +Merges 2 dictionaries\. +If any collisions with keys occur, the values of dict2 will overwrite those of dict1\. + +```clojure +(merged dict2 dict1) +``` + +### merged\_with + +```clojure +(All (_ a b) (-> (-> b b b) (Dictionary a b) (Dictionary a b) (Dictionary a b))) +``` + +Merges 2 dictionaries\. +If any collisions with keys occur, a new value will be computed by applying 'f' to the values of dict2 and dict1\. + +```clojure +(merged_with f dict2 dict1) +``` + +### of\_list + +```clojure +(All (_ a b) (-> (library/lux/abstract/hash.Hash a) (.List [a b]) (Dictionary a b))) +``` + +```clojure +(of_list key_hash kvs) +``` + +### re\_bound + +```clojure +(All (_ a b) (-> a a (Dictionary a b) (Dictionary a b))) +``` + +If there is a value under 'from\_key', remove 'from\_key' and store the value under 'to\_key'\. + +```clojure +(re_bound from_key to_key dict) +``` + +### revised + +```clojure +(All (_ a b) (-> a (-> b b) (Dictionary a b) (Dictionary a b))) +``` + +Transforms the value located at key \(if available\), using the given function\. + +```clojure +(revised key f dict) +``` + +### revised' + +```clojure +(All (_ a b) (-> a b (-> b b) (Dictionary a b) (Dictionary a b))) +``` + +Updates the value at the key; if it exists\. +Otherwise, puts a value by applying the function to a default\. + +```clojure +(revised' key default f dict) +``` + +### size + +```clojure +(All (_ a b) (-> (Dictionary a b) .Nat)) +``` + +### sub + +```clojure +(All (_ a b) (-> (.List a) (Dictionary a b) (Dictionary a b))) +``` + +A sub\-dictionary, with only the specified keys\. + +```clojure +(sub keys dict) +``` + +### value + +```clojure +(All (_ a b) (-> a (Dictionary a b) (.Maybe b))) +``` + +```clojure +(value key dict) +``` + +### values + +```clojure +(All (_ a b) (-> (Dictionary a b) (.List b))) +``` + +___ + +# library/lux/data/collection/dictionary/ordered + +## Definitions + +### \(Dictionary key value\) + +```clojure +... .Type +[(library/lux/abstract/order.Order key) (.Maybe (Node key value))] +``` + +A dictionary data\-structure with ordered entries\. + +### empty + +```clojure +(All (_ a b) (-> (library/lux/abstract/order.Order a) (Dictionary a b))) +``` + +An empty dictionary, employing the given order\. + +```clojure +(empty order) +``` + +### empty? + +```clojure +(All (_ a b) (-> (Dictionary a b) .Bit)) +``` + +### entries + +```clojure +(All (_ a b) (-> (Dictionary a b) (.List [a b]))) +``` + +### equivalence + +```clojure +(All (_ a b) (-> (library/lux/abstract/equivalence.Equivalence b) (library/lux/abstract/equivalence.Equivalence (Dictionary a b)))) +``` + +### has + +```clojure +(All (_ a b) (-> a b (Dictionary a b) (Dictionary a b))) +``` + +```clojure +(has key value dict) +``` + +### key? + +```clojure +(All (_ a b) (-> (Dictionary a b) a .Bit)) +``` + +```clojure +(key? dict key) +``` + +### keys + +```clojure +(All (_ a b) (-> (Dictionary a b) (.List a))) +``` + +### lacks + +```clojure +(All (_ a b) (-> a (Dictionary a b) (Dictionary a b))) +``` + +```clojure +(lacks key dict) +``` + +### max + +```clojure +(All (_ a b) (-> (Dictionary a b) (.Maybe b))) +``` + +Yields value under the maximum key\. + +```clojure + ( + + +max dict) +``` + +### min + +```clojure +(All (_ a b) (-> (Dictionary a b) (.Maybe b))) +``` + +Yields value under the minimum key\. + +```clojure + ( + +min dict) +``` + +### of\_list + +```clojure +(All (_ a b) (-> (library/lux/abstract/order.Order a) (.List [a b]) (Dictionary a b))) +``` + +```clojure +(of_list order list) +``` + +### revised + +```clojure +(All (_ a b) (-> a (-> b b) (Dictionary a b) (Dictionary a b))) +``` + +```clojure +(revised key transform dict) +``` + +### size + +```clojure +(All (_ a b) (-> (Dictionary a b) .Nat)) +``` + +```clojure +(size dict) +``` + +### value + +```clojure +(All (_ a b) (-> a (Dictionary a b) (.Maybe b))) +``` + +```clojure +(value key dict) +``` + +### values + +```clojure +(All (_ a b) (-> (Dictionary a b) (.List b))) +``` + +___ + +# library/lux/data/collection/dictionary/plist + +## Definitions + +### \(PList it\) + +```clojure +... .Type +(.List [.Text it]) +``` + +A property list\. +It's a simple dictionary\-like structure with Text keys\. + +### contains? + +```clojure +(All (_ a) (-> .Text (PList a) .Bit)) +``` + +```clojure +(contains? key properties) +``` + +### empty + +```clojure +PList +``` + +### empty? + +```clojure +(All (_ a) (-> (PList a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (PList a)))) +``` + +### has + +```clojure +(All (_ a) (-> .Text a (PList a) (PList a))) +``` + +```clojure +(has key val properties) +``` + +### keys + +```clojure +(All (_ a) (-> (PList a) (.List .Text))) +``` + +### lacks + +```clojure +(All (_ a) (-> .Text (PList a) (PList a))) +``` + +```clojure +(lacks key properties) +``` + +### revised + +```clojure +(All (_ a) (-> .Text (-> a a) (PList a) (PList a))) +``` + +```clojure +(revised key f properties) +``` + +### size + +```clojure +(All (_ a) (-> (PList a) .Nat)) +``` + +### value + +```clojure +(All (_ a) (-> .Text (PList a) (.Maybe a))) +``` + +```clojure +(value key properties) +``` + +### values + +```clojure +(All (_ a) (-> (PList a) (.List a))) +``` + +___ + +# library/lux/data/collection/list + +## Definitions + +### after + +```clojure +(All (_ a) (-> .Nat (.List a) (.List a))) +``` + +```clojure + ( + + +after n xs) +``` + +### all + +```clojure +(All (_ a b) (-> (-> a (.Maybe b)) (.List a) (.List b))) +``` + +```clojure +(all check xs) +``` + +### any? + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) .Bit)) +``` + +```clojure + ( + + +any? predicate items) +``` + +### apply + +```clojure +(library/lux/abstract/apply.Apply .List) +``` + +### empty? + +```clojure +(All (_ a) (library/lux/abstract/predicate.Predicate (.List a))) +``` + +```clojure +(empty? xs) +``` + +### enumeration + +```clojure +(All (_ a) (-> (.List a) (.List [.Nat a]))) +``` + +Pairs every element in the list with its index, starting at 0\. + +```clojure +(enumeration xs) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (.List a)))) +``` + +### every? + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) .Bit)) +``` + +```clojure + ( + +every? predicate items) +``` + +### example + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) (.Maybe a))) +``` + +Yields the first value in the list that satisfies the predicate\. + +```clojure +(example predicate xs) +``` + +### first + +```clojure +(All (_ a) (-> .Nat (.List a) (.List a))) +``` + +```clojure + ( + +first n xs) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor .List) +``` + +### hash + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (library/lux/abstract/hash.Hash (.List a)))) +``` + +### head + +```clojure +(All (_ a) (-> (.List a) (.Maybe a))) +``` + +Yields the first element of a list\. + +```clojure + ( + +head xs) +``` + +### indices + +```clojure +(All (_ a) (-> .Nat (.List .Nat))) +``` + +Produces all the valid indices for a given size\. + +```clojure +(indices size) +``` + +### inits + +```clojure +(All (_ a) (-> (.List a) (.Maybe (.List a)))) +``` + +For a list of size N, yields the first N\-1 elements\. +Will yield a \#\.None for empty lists\. + +```clojure +(inits xs) +``` + +### interposed + +```clojure +(All (_ a) (-> a (.List a) (.List a))) +``` + +Puts a value between every two elements in the list\. + +```clojure +(interposed sep xs) +``` + +### item + +```clojure +(All (_ a) (-> .Nat (.List a) (.Maybe a))) +``` + +Fetches the element at the specified index\. + +```clojure +(item i xs) +``` + +### iterations + +```clojure +(All (_ a) (-> (-> a (.Maybe a)) a (.List a))) +``` + +Generates a list element by element until the function returns \#\.None\. + +```clojure +(iterations f x) +``` + +### last + +```clojure +(All (_ a) (-> (.List a) (.Maybe a))) +``` + +```clojure +(last xs) +``` + +### lifted + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (a b) (a (.List b)))) +``` + +Wraps a monadic value with List machinery\. + +```clojure +(lifted monad) +``` + +### member? + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (.List a) a .Bit)) +``` + +```clojure +(member? eq xs x) +``` + +### mix + +```clojure +(library/lux/abstract/mix.Mix .List) +``` + +### mixes + +```clojure +(All (_ a b) (-> (-> a b b) b (.List a) (.List b))) +``` + +```clojure +(mixes f init inputs) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad .List) +``` + +### monoid + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (.List a))) +``` + +### one + +```clojure +(All (_ a b) (-> (-> a (.Maybe b)) (.List a) (.Maybe b))) +``` + +```clojure +(one check xs) +``` + +### only + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) (.List a))) +``` + +A list with only values that satisfy the predicate\. + +```clojure +(only keep? xs) +``` + +### pairs + +```clojure +(All (_ a) (-> (.List a) (.List [a a]))) +``` + +Cut the list into pairs of 2\. +Caveat emptor: If the list has an un\-even number of elements, the last one will be skipped\. + +```clojure +(pairs xs) +``` + +### partition + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) [(.List a) (.List a)])) +``` + +Divide the list into all elements that satisfy a predicate, and all elements that do not\. + +```clojure +(partition satisfies? list) +``` + +### repeated + +```clojure +(All (_ a) (-> .Nat a (.List a))) +``` + +A list of the value x, repeated n times\. + +```clojure +(repeated n x) +``` + +### reversed + +```clojure +(All (_ a) (-> (.List a) (.List a))) +``` + +```clojure +(reversed xs) +``` + +### size + +```clojure +(All (_ a) (-> (.List a) .Nat)) +``` + +```clojure +(size list) +``` + +### sorted + +```clojure +(All (_ a) (-> (-> a a .Bit) (.List a) (.List a))) +``` + +A list ordered by a comparison function\. + +```clojure +(sorted < xs) +``` + +### split\_at + +```clojure +(All (_ a) (-> .Nat (.List a) [(.List a) (.List a)])) +``` + +```clojure +(split_at n xs) +``` + +### split\_when + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) [(.List a) (.List a)])) +``` + +Segment the list by using a predicate to tell when to cut\. + +```clojure +(split_when predicate xs) +``` + +### sub + +```clojure +(All (_ a) (-> .Nat (.List a) (.List (.List a)))) +``` + +Segment the list into sub\-lists of \(at most\) the given size\. + +```clojure +(sub size list) +``` + +### tail + +```clojure +(All (_ a) (-> (.List a) (.Maybe (.List a)))) +``` + +For a list of size N, yields the N\-1 elements after the first one\. + +```clojure + ( + + +tail xs) +``` + +### together + +```clojure +(All (_ a) (-> (.List (.List a)) (.List a))) +``` + +The sequential combination of all the lists\. + +### until + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) (.List a))) +``` + +```clojure + ( + + +until predicate xs) +``` + +### when + +```clojure +.Macro +``` + +Can be used as a guard in \(co\)monadic be/do expressions\. + +```clojure +(do monad + [value (do_something 1 2 3) + when (passes_test? value)] + (do_something_else 4 5 6)) +``` + +### while + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (.List a) (.List a))) +``` + +```clojure + ( + +while predicate xs) +``` + +### with + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (library/lux/abstract/monad.Monad (All (_ b) (a (.List b)))))) +``` + +Enhances a monad with List functionality\. + +```clojure +(with monad) +``` + +### zipped + +```clojure +.Macro +``` + +Create list zippers with the specified number of input lists\. + +```clojure +(def: zipped/2 (zipped 2)) + +(def: zipped/3 (zipped 3)) + +(zipped/3 xs ys zs) + +((zipped 3) xs ys zs) +``` + +### zipped/2 + +```clojure +(All (_ a b) (-> (.List a) (.List b) (.List [a b]))) +``` + +### zipped/3 + +```clojure +(All (_ a b c) (-> (.List a) (.List b) (.List c) (.List [a b c]))) +``` + +### zipped\_with + +```clojure +.Macro +``` + +Create list zippers with the specified number of input lists\. + +```clojure +(def: zipped_with/2 (zipped_with 2)) + +(def: zipped_with/3 (zipped_with 3)) + +(zipped_with/2 + xs ys) + +((zipped_with 2) + xs ys) +``` + +### zipped\_with/2 + +```clojure +(All (_ a b c) (-> (-> a b c) (.List a) (.List b) (.List c))) +``` + +### zipped\_with/3 + +```clojure +(All (_ a b c d) (-> (-> a b c d) (.List a) (.List b) (.List c) (.List d))) +``` + +___ + +# library/lux/data/collection/queue + +## Definitions + +### \(Queue it\) + +```clojure +... .Type +[(.List it) (.List it)] +``` + +A first\-in, first\-out sequential data\-structure\. + +### empty + +```clojure +Queue +``` + +### empty? + +```clojure +(All (_ a) (-> (Queue a) .Bit)) +``` + +### end + +```clojure +(All (_ a) (-> a (Queue a) (Queue a))) +``` + +```clojure +(end val queue) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Queue a)))) +``` + +### front + +```clojure +(All (_ a) (-> (Queue a) (.Maybe a))) +``` + +Yields the first value in the queue, if any\. + +### functor + +```clojure +(library/lux/abstract/functor.Functor Queue) +``` + +### list + +```clojure +(All (_ a) (-> (Queue a) (.List a))) +``` + +```clojure +(list queue) +``` + +### member? + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (Queue a) a .Bit)) +``` + +```clojure +(member? equivalence queue member) +``` + +### next + +```clojure +(All (_ a) (-> (Queue a) (Queue a))) +``` + +```clojure +(next queue) +``` + +### of\_list + +```clojure +(All (_ a) (-> (.List a) (Queue a))) +``` + +```clojure +(of_list entries) +``` + +### size + +```clojure +(All (_ a) (-> (Queue a) .Nat)) +``` + +___ + +# library/lux/data/collection/queue/priority + +## Definitions + +### Priority + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +### \(Queue it\) + +```clojure +... .Type +(primitive "library/lux/data/collection/queue/priority.Queue" it) +``` + +### empty + +```clojure +Queue +``` + +### empty? + +```clojure +(All (_ a) (-> (Queue a) .Bit)) +``` + +### end + +```clojure +(All (_ a) (-> Priority a (Queue a) (Queue a))) +``` + +```clojure +(end priority value queue) +``` + +### front + +```clojure +(All (_ a) (-> (Queue a) (.Maybe a))) +``` + +### max + +```clojure +Priority +``` + +### member? + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (Queue a) a .Bit)) +``` + +```clojure +(member? equivalence queue member) +``` + +### min + +```clojure +Priority +``` + +### next + +```clojure +(All (_ a) (-> (Queue a) (Queue a))) +``` + +### size + +```clojure +(All (_ a) (-> (Queue a) .Nat)) +``` + +___ + +# library/lux/data/collection/row + +## Definitions + +### \(Row it\) + +```clojure +... .Type +[Level .Nat (Hierarchy it) (Base it)] +``` + +A sequential data\-structure with fast random access\. + +### any? + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (Row a) .Bit)) +``` + +### apply + +```clojure +(library/lux/abstract/apply.Apply Row) +``` + +### empty + +```clojure +Row +``` + +### empty? + +```clojure +(All (_ a) (-> (Row a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Row a)))) +``` + +### every? + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (Row a) .Bit)) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Row) +``` + +### has + +```clojure +(All (_ a) (-> .Nat a (Row a) (library/lux/control/try.Try (Row a)))) +``` + +```clojure +(has idx val row) +``` + +### index\_out\_of\_bounds + +```clojure +(All (_ a) (library/lux/control/exception.Exception [(Row a) .Nat])) +``` + +### item + +```clojure +(All (_ a) (-> .Nat (Row a) (library/lux/control/try.Try a))) +``` + +```clojure +(item idx row) +``` + +### list + +```clojure +(All (_ a) (-> (Row a) (.List a))) +``` + +```clojure +(list row) +``` + +### member? + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (Row a) a .Bit)) +``` + +```clojure +(member? equivalence row val) +``` + +### mix + +```clojure +(library/lux/abstract/mix.Mix Row) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Row) +``` + +### monoid + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (Row a))) +``` + +### of\_list + +```clojure +(All (_ a) (-> (.List a) (Row a))) +``` + +### prefix + +```clojure +(All (_ a) (-> (Row a) (Row a))) +``` + +```clojure +(prefix row) +``` + +### reversed + +```clojure +(All (_ a) (-> (Row a) (Row a))) +``` + +### revised + +```clojure +(All (_ a) (-> .Nat (-> a a) (Row a) (library/lux/control/try.Try (Row a)))) +``` + +```clojure +(revised idx f row) +``` + +### row + +```clojure +.Macro +``` + +Row literals\. + +```clojure +(: (Row Nat) + (row 12 34 56 78 90)) +``` + +### size + +```clojure +(All (_ a) (-> (Row a) .Nat)) +``` + +### suffix + +```clojure +(All (_ a) (-> a (Row a) (Row a))) +``` + +```clojure +(suffix val row) +``` + +### within\_bounds? + +```clojure +(All (_ a) (-> (Row a) .Nat .Bit)) +``` + +Determines whether the index is within the bounds of the row\. + +```clojure +(within_bounds? row idx) +``` + +___ + +# library/lux/data/collection/sequence + +## Definitions + +### \(Sequence it\) + +```clojure +... .Type +(library/lux/control/continuation.Cont [it (Sequence it)]) +``` + +An infinite sequence of values\. + +### ^sequence& + +```clojure +.Macro +``` + +Allows destructuring of sequences in pattern\-matching expressions\. +Caveat emptor: Only use it for destructuring, and not for testing values within the sequences\. + +```clojure +(let [(^sequence& x y z _tail) (some_sequence_func +1 +2 +3)] + (func x y z)) +``` + +### after + +```clojure +(All (_ a) (-> .Nat (Sequence a) (Sequence a))) +``` + +```clojure +( + + + after pred xs) +``` + +### comonad + +```clojure +(library/lux/abstract/comonad.CoMonad Sequence) +``` + +### cycle + +```clojure +(All (_ a) (-> [a (.List a)] (Sequence a))) +``` + +Go over the elements of a list forever\. +The list should not be empty\. + +```clojure +(cycle [start next]) +``` + +### first + +```clojure +(All (_ a) (-> .Nat (Sequence a) (.List a))) +``` + +```clojure + ( + + + + + +first pred xs) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Sequence) +``` + +### head + +```clojure +(All (_ a) (-> (Sequence a) a)) +``` + +### item + +```clojure +(All (_ a) (-> .Nat (Sequence a) a)) +``` + +```clojure +(item idx sequence) +``` + +### iterations + +```clojure +(All (_ a b) (-> (-> a [a b]) a (Sequence b))) +``` + +A stateful way of infinitely calculating the values of a sequence\. + +```clojure +(iterations step init) +``` + +### only + +```clojure +(All (_ a) (-> (-> a .Bit) (Sequence a) (Sequence a))) +``` + +A new sequence only with items that satisfy the predicate\. + +```clojure +(only predicate sequence) +``` + +### partition + +```clojure +(All (_ a) (-> (-> a .Bit) (Sequence a) [(Sequence a) (Sequence a)])) +``` + +Split a sequence in two based on a predicate\. +The left side contains all entries for which the predicate is \#1\. +The right side contains all entries for which the predicate is \#0\. + +```clojure +(partition left? xs) +``` + +### repeated + +```clojure +(All (_ a) (-> a (Sequence a))) +``` + +Repeat a value forever\. + +```clojure +(repeated x) +``` + +### split\_at + +```clojure +(All (_ a) (-> .Nat (Sequence a) [(.List a) (Sequence a)])) +``` + +```clojure + ( + + +split_at pred xs) +``` + +### split\_when + +```clojure +(All (_ a) (-> (-> a .Bit) (Sequence a) [(.List a) (Sequence a)])) +``` + +```clojure + ( + +split_when pred xs) +``` + +### tail + +```clojure +(All (_ a) (-> (Sequence a) (Sequence a))) +``` + +### until + +```clojure +(All (_ a) (-> (-> a .Bit) (Sequence a) (Sequence a))) +``` + +```clojure +( + + until pred xs) +``` + +### while + +```clojure +(All (_ a) (-> (-> a .Bit) (Sequence a) (.List a))) +``` + +```clojure + ( + + + + +while pred xs) +``` + +___ + +# library/lux/data/collection/set + +## Definitions + +### \(Set it\) + +```clojure +... .Type +(library/lux/data/collection/dictionary.Dictionary it .Any) +``` + +### difference + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +```clojure +(difference sub base) +``` + +### empty + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (Set a))) +``` + +### empty? + +```clojure +(All (_ a) (-> (Set a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (library/lux/abstract/equivalence.Equivalence (Set a))) +``` + +### has + +```clojure +(All (_ a) (-> a (Set a) (Set a))) +``` + +```clojure +(has elem set) +``` + +### hash + +```clojure +(All (_ a) (library/lux/abstract/hash.Hash (Set a))) +``` + +### intersection + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +```clojure +(intersection filter base) +``` + +### lacks + +```clojure +(All (_ a) (-> a (Set a) (Set a))) +``` + +### list + +```clojure +(All (_ a) (-> (Set a) (.List a))) +``` + +### member? + +```clojure +(All (_ a) (-> (Set a) a .Bit)) +``` + +### member\_hash + +```clojure +(All (_ a) (-> (Set a) (library/lux/abstract/hash.Hash a))) +``` + +### monoid + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (library/lux/abstract/monoid.Monoid (Set a)))) +``` + +### of\_list + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (.List a) (Set a))) +``` + +### predicate + +```clojure +(All (_ a) (-> (Set a) (library/lux/abstract/predicate.Predicate a))) +``` + +### size + +```clojure +(All (_ a) (-> (Set a) .Nat)) +``` + +### sub? + +```clojure +(All (_ a) (-> (Set a) (Set a) .Bit)) +``` + +```clojure +(sub? super sub) +``` + +### super? + +```clojure +(All (_ a) (-> (Set a) (Set a) .Bit)) +``` + +```clojure +(super? sub super) +``` + +### union + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +___ + +# library/lux/data/collection/set/multi + +## Definitions + +### \(Set it\) + +```clojure +... .Type +(primitive "library/lux/data/collection/set/multi.Set" it) +``` + +A set that keeps track of repetition in its entries\. + +### difference + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +```clojure + ( + + + + +difference parameter subject) +``` + +### empty + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (Set a))) +``` + +### empty? + +```clojure +(All (_ a) (-> (Set a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (library/lux/abstract/equivalence.Equivalence (Set a))) +``` + +### has + +```clojure +(All (_ a) (-> .Nat a (Set a) (Set a))) +``` + +```clojure +(has multiplicity elem set) +``` + +### hash + +```clojure +(All (_ a) (library/lux/abstract/hash.Hash (Set a))) +``` + +### intersection + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +```clojure + ( + + + +intersection parameter subject) +``` + +### lacks + +```clojure +(All (_ a) (-> .Nat a (Set a) (Set a))) +``` + +```clojure +(lacks multiplicity elem set) +``` + +### list + +```clojure +(All (_ a) (-> (Set a) (.List a))) +``` + +### member? + +```clojure +(All (_ a) (-> (Set a) a .Bit)) +``` + +```clojure +(member? set elem) +``` + +### multiplicity + +```clojure +(All (_ a) (-> (Set a) a .Nat)) +``` + +```clojure +(multiplicity set elem) +``` + +### of\_list + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) (.List a) (Set a))) +``` + +### of\_set + +```clojure +(All (_ a) (-> (library/lux/data/collection/set.Set a) (Set a))) +``` + +### size + +```clojure +(All (_ a) (-> (Set a) .Nat)) +``` + +### sub? + +```clojure +(All (_ a) (-> (Set a) (Set a) .Bit)) +``` + +Is 'subject' a sub\-set of 'reference'? + +```clojure +(sub? reference subject) +``` + +### sum + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +```clojure + ( + + +sum parameter subject) +``` + +### super? + +```clojure +(All (_ a) (-> (Set a) (Set a) .Bit)) +``` + +Is 'subject' a super\-set of 'reference'? + +### support + +```clojure +(All (_ a) (-> (Set a) (library/lux/data/collection/set.Set a))) +``` + +A set of the unique \(non repeated\) members\. + +```clojure +(support set) +``` + +### union + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +```clojure + ( + +union parameter subject) +``` + +___ + +# library/lux/data/collection/set/ordered + +## Definitions + +### \(Set it\) + +```clojure +... .Type +(primitive "library/lux/data/collection/set/ordered.Set" it) +``` + +A set with ordered entries\. + +### difference + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +```clojure +(difference param subject) +``` + +### empty + +```clojure +(All (_ a) (-> (library/lux/abstract/order.Order a) (Set a))) +``` + +### empty? + +```clojure +(All (_ a) (-> (Set a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (library/lux/abstract/equivalence.Equivalence (Set a))) +``` + +### has + +```clojure +(All (_ a) (-> a (Set a) (Set a))) +``` + +```clojure +(has elem set) +``` + +### intersection + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +### lacks + +```clojure +(All (_ a) (-> a (Set a) (Set a))) +``` + +```clojure +(lacks elem set) +``` + +### list + +```clojure +(All (_ a) (-> (Set a) (.List a))) +``` + +### max + +```clojure +(All (_ a) (-> (Set a) (.Maybe a))) +``` + +### member? + +```clojure +(All (_ a) (-> (Set a) a .Bit)) +``` + +```clojure +(member? set elem) +``` + +### min + +```clojure +(All (_ a) (-> (Set a) (.Maybe a))) +``` + +### of\_list + +```clojure +(All (_ a) (-> (library/lux/abstract/order.Order a) (.List a) (Set a))) +``` + +### size + +```clojure +(All (_ a) (-> (Set a) .Nat)) +``` + +### sub? + +```clojure +(All (_ a) (-> (Set a) (Set a) .Bit)) +``` + +Is 'sub' a sub\-set of 'super'? + +```clojure +(sub? super sub) +``` + +### super? + +```clojure +(All (_ a) (-> (Set a) (Set a) .Bit)) +``` + +Is 'super' a super\-set of 'sub'? + +```clojure +(super? sub super) +``` + +### union + +```clojure +(All (_ a) (-> (Set a) (Set a) (Set a))) +``` + +___ + +# library/lux/data/collection/stack + +## Definitions + +### \(Stack it\) + +```clojure +... .Type +(primitive "library/lux/data/collection/stack.Stack" it) +``` + +A first\-in, last\-out sequential data\-structure\. + +### empty + +```clojure +Stack +``` + +### empty? + +```clojure +(All (_ a) (-> (Stack a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Stack a)))) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Stack) +``` + +### next + +```clojure +(All (_ a) (-> (Stack a) (.Maybe [a (Stack a)]))) +``` + +```clojure +(next stack) +``` + +### size + +```clojure +(All (_ a) (-> (Stack a) .Nat)) +``` + +### top + +```clojure +(All (_ a) (-> a (Stack a) (Stack a))) +``` + +```clojure +(top value stack) +``` + +### value + +```clojure +(All (_ a) (-> (Stack a) (.Maybe a))) +``` + +Yields the top value in the stack, if any\. + +```clojure +(value stack) +``` + +___ + +# library/lux/data/collection/tree + +## Definitions + +### \(Tree it\) + +```clojure +... .Type +[it (.List (Tree it))] +``` + +A generic tree data\-structure\. + +### branch + +```clojure +(All (_ a) (-> a (.List (Tree a)) (Tree a))) +``` + +```clojure +(branch value children) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Tree a)))) +``` + +### flat + +```clojure +(All (_ a) (-> (Tree a) (.List a))) +``` + +All the leaf values of the tree, in order\. + +```clojure +(flat tree) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Tree) +``` + +### leaf + +```clojure +(All (_ a) (-> a (Tree a))) +``` + +```clojure +(leaf value) +``` + +### mix + +```clojure +(library/lux/abstract/mix.Mix Tree) +``` + +### tree + +```clojure +.Macro +``` + +Tree literals\. + +```clojure +(: (Tree Nat) + (tree 12 + {34 {} + 56 {} + 78 {90 {}}})) +``` + +___ + +# library/lux/data/collection/tree/finger + +## Definitions + +### \(Builder @ tag\) + +```clojure +... .Type +[(All (_ c) (-> tag c (Tree @ tag c))) (All (_ c) (-> (Tree @ tag c) (Tree @ tag c) (Tree @ tag c)))] +``` + +A builder for finter tree structures\. + +### \(Tree @ tag value\) + +```clojure +... .Type +(primitive "library/lux/data/collection/tree/finger.Tree" @ tag value) +``` + +A finger tree\. + +### builder + +```clojure +(All (_ a) (Ex (_ b) (-> (library/lux/abstract/monoid.Monoid a) (Builder b a)))) +``` + +A new builder using the given monoid\. + +```clojure +(builder monoid) +``` + +### exists? + +```clojure +(All (_ a b c) (-> (library/lux/abstract/predicate.Predicate b) (Tree a b c) .Bit)) +``` + +Verifies that a value exists which meets the predicate\. + +```clojure +(exists? predicate tree) +``` + +### one + +```clojure +(All (_ a b c) (-> (library/lux/abstract/predicate.Predicate b) (Tree a b c) (.Maybe c))) +``` + +Finds one value that meets the predicate\. + +```clojure +(one predicate tree) +``` + +### root + +```clojure +(All (_ a b c) (-> (Tree a b c) (.Either c [(Tree a b c) (Tree a b c)]))) +``` + +### tag + +```clojure +(All (_ a b c) (-> (Tree a b c) b)) +``` + +### tags + +```clojure +(All (_ a b c) (-> (Tree a b c) (.List b))) +``` + +```clojure +(tags tree) +``` + +### value + +```clojure +(All (_ a b c) (-> (Tree a b c) c)) +``` + +```clojure +(value tree) +``` + +### values + +```clojure +(All (_ a b c) (-> (Tree a b c) (.List c))) +``` + +```clojure +(values tree) +``` + +___ + +# library/lux/data/collection/tree/zipper + +## Definitions + +### \(Zipper it\) + +```clojure +... .Type +[(.Maybe (Family Zipper it)) (library/lux/data/collection/tree.Tree it)] +``` + +Tree zippers, for easy navigation and editing of trees\. + +### adopt + +```clojure +(All (_ a) (-> a (Zipper a) (Zipper a))) +``` + +```clojure +(adopt value zipper) +``` + +### branch? + +```clojure +(All (_ a) (-> (Zipper a) .Bit)) +``` + +### comonad + +```clojure +(library/lux/abstract/comonad.CoMonad Zipper) +``` + +### down + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### end + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### end? + +```clojure +(All (_ a) (-> (Zipper a) .Bit)) +``` + +### equivalence + +```clojure +(All (_ a) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence (Zipper a)))) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Zipper) +``` + +### insert\_left + +```clojure +(All (_ a) (-> a (Zipper a) (.Maybe (Zipper a)))) +``` + +### insert\_right + +```clojure +(All (_ a) (-> a (Zipper a) (.Maybe (Zipper a)))) +``` + +### interpose + +```clojure +(All (_ a) (-> a (Zipper a) (Zipper a))) +``` + +```clojure +(interpose value zipper) +``` + +### leaf? + +```clojure +(All (_ a) (-> (Zipper a) .Bit)) +``` + +### left + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### leftmost + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### next + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### previous + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### remove + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### right + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### rightmost + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### set + +```clojure +(All (_ a) (-> a (Zipper a) (Zipper a))) +``` + +```clojure +(set value zipper) +``` + +### start + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### start? + +```clojure +(All (_ a) (-> (Zipper a) .Bit)) +``` + +### tree + +```clojure +(All (_ a) (-> (Zipper a) (library/lux/data/collection/tree.Tree a))) +``` + +### up + +```clojure +(All (_ a) (-> (Zipper a) (.Maybe (Zipper a)))) +``` + +### update + +```clojure +(All (_ a) (-> (-> a a) (Zipper a) (Zipper a))) +``` + +```clojure +(update transform zipper) +``` + +### value + +```clojure +(All (_ a) (-> (Zipper a) a)) +``` + +### zipper + +```clojure +(All (_ a) (-> (library/lux/data/collection/tree.Tree a) (Zipper a))) +``` + +___ + +# library/lux/data/color + +## Definitions + +### Alpha + +```clojure +... .Type +(primitive "#I64" (primitive "#Rev")) +``` + +The degree of transparency of a pigment\. + +### CMYK + +```clojure +... .Type +[.Frac .Frac .Frac .Frac] +``` + +Cyan\-Magenta\-Yellow\-Key color format\. + +### Color + +```clojure +... .Type +(primitive "library/lux/data/color.Color") +``` + +A color value, independent of color format\. + +### HSB + +```clojure +... .Type +[.Frac .Frac .Frac] +``` + +Hue\-Saturation\-Brightness color format\. + +### HSL + +```clojure +... .Type +[.Frac .Frac .Frac] +``` + +Hue\-Saturation\-Lightness color format\. + +### Palette + +```clojure +... .Type +(-> Spread .Nat Color (.List Color)) +``` + +### Pigment + +```clojure +... .Type +[Color Alpha] +``` + +A color with some degree of transparency\. + +### RGB + +```clojure +... .Type +[.Nat .Nat .Nat] +``` + +Red\-Green\-Blue color format\. + +### Spread + +```clojure +... .Type +(primitive "#Frac") +``` + +### addition + +```clojure +(library/lux/abstract/monoid.Monoid Color) +``` + +### analogous + +```clojure +Palette +``` + +A analogous palette\. + +```clojure +(analogous spread variations color) +``` + +### black + +```clojure +Color +``` + +### brighter + +```clojure +(-> .Frac Color Color) +``` + +```clojure + ( + + +brighter ratio color) +``` + +### clash + +```clojure +(-> Color [Color Color Color]) +``` + +A clash color scheme\. + +### cmyk + +```clojure +(-> Color CMYK) +``` + +### complement + +```clojure +(-> Color Color) +``` + +The opposite color\. + +```clojure +(complement color) +``` + +### darker + +```clojure +(-> .Frac Color Color) +``` + +```clojure + ( + +darker ratio color) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Color) +``` + +### gray\_scale + +```clojure +(-> Color Color) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash Color) +``` + +### hsb + +```clojure +(-> Color HSB) +``` + +### hsl + +```clojure +(-> Color HSL) +``` + +### interpolated + +```clojure +(-> .Frac Color Color Color) +``` + +```clojure +(interpolated ratio end start) +``` + +### monochromatic + +```clojure +Palette +``` + +A monochromatic palette\. + +```clojure +(monochromatic spread variations color) +``` + +### of\_cmyk + +```clojure +(-> CMYK Color) +``` + +### of\_hsb + +```clojure +(-> HSB Color) +``` + +### of\_hsl + +```clojure +(-> HSL Color) +``` + +### of\_rgb + +```clojure +(-> RGB Color) +``` + +### opaque + +```clojure +Alpha +``` + +The minimum degree of transparency\. + +### rgb + +```clojure +(-> Color RGB) +``` + +### saturated + +```clojure +(-> .Frac Color Color) +``` + +```clojure + ( + + + +saturated ratio color) +``` + +### split\_complement + +```clojure +(-> Color [Color Color Color]) +``` + +A split\-complement color scheme\. + +### square + +```clojure +(-> Color [Color Color Color Color]) +``` + +A square color scheme\. + +### subtraction + +```clojure +(library/lux/abstract/monoid.Monoid Color) +``` + +### tetradic + +```clojure +(-> Color [Color Color Color Color]) +``` + +A tetradic color scheme\. + +### translucent + +```clojure +Alpha +``` + +The average degree of transparency\. + +### transparent + +```clojure +Alpha +``` + +The maximum degree of transparency\. + +### triad + +```clojure +(-> Color [Color Color Color]) +``` + +A triad color scheme\. + +### un\_saturated + +```clojure +(-> .Frac Color Color) +``` + +```clojure + ( + + + + +un_saturated ratio color) +``` + +### white + +```clojure +Color +``` + +___ + +# library/lux/data/color/named + +## Definitions + +### alice\_blue + +```clojure +library/lux/data/color.Color +``` + +R:F0 G:F8 B:FF | alice blue + +### antique\_white + +```clojure +library/lux/data/color.Color +``` + +R:FA G:EB B:D7 | antique white + +### aqua + +```clojure +library/lux/data/color.Color +``` + +R:0 G:FF B:FF | aqua + +### aquamarine + +```clojure +library/lux/data/color.Color +``` + +R:7F G:FF B:D4 | aquamarine + +### azure + +```clojure +library/lux/data/color.Color +``` + +R:F0 G:FF B:FF | azure + +### beige + +```clojure +library/lux/data/color.Color +``` + +R:F5 G:F5 B:DC | beige + +### bisque + +```clojure +library/lux/data/color.Color +``` + +R:FF G:E4 B:C4 | bisque + +### black + +```clojure +library/lux/data/color.Color +``` + +R:0 G:0 B:0 | black + +### blanched\_almond + +```clojure +library/lux/data/color.Color +``` + +R:FF G:EB B:CD | blanched almond + +### blue + +```clojure +library/lux/data/color.Color +``` + +R:0 G:0 B:FF | blue + +### blue\_violet + +```clojure +library/lux/data/color.Color +``` + +R:8A G:2B B:E2 | blue violet + +### brown + +```clojure +library/lux/data/color.Color +``` + +R:A5 G:2A B:2A | brown + +### burly\_wood + +```clojure +library/lux/data/color.Color +``` + +R:DE G:B8 B:87 | burly wood + +### cadet\_blue + +```clojure +library/lux/data/color.Color +``` + +R:5F G:9E B:A0 | cadet blue + +### chartreuse + +```clojure +library/lux/data/color.Color +``` + +R:7F G:FF B:0 | chartreuse + +### chocolate + +```clojure +library/lux/data/color.Color +``` + +R:D2 G:69 B:1E | chocolate + +### coral + +```clojure +library/lux/data/color.Color +``` + +R:FF G:7F B:50 | coral + +### cornflower\_blue + +```clojure +library/lux/data/color.Color +``` + +R:64 G:95 B:ED | cornflower blue + +### cornsilk + +```clojure +library/lux/data/color.Color +``` + +R:FF G:F8 B:DC | cornsilk + +### crimson + +```clojure +library/lux/data/color.Color +``` + +R:DC G:14 B:3C | crimson + +### cyan + +```clojure +library/lux/data/color.Color +``` + +R:0 G:FF B:FF | cyan + +### dark\_blue + +```clojure +library/lux/data/color.Color +``` + +R:0 G:0 B:8B | dark blue + +### dark\_cyan + +```clojure +library/lux/data/color.Color +``` + +R:0 G:8B B:8B | dark cyan + +### dark\_goldenrod + +```clojure +library/lux/data/color.Color +``` + +R:B8 G:86 B:B | dark goldenrod + +### dark\_gray + +```clojure +library/lux/data/color.Color +``` + +R:A9 G:A9 B:A9 | dark gray + +### dark\_green + +```clojure +library/lux/data/color.Color +``` + +R:0 G:64 B:0 | dark green + +### dark\_khaki + +```clojure +library/lux/data/color.Color +``` + +R:BD G:B7 B:6B | dark khaki + +### dark\_magenta + +```clojure +library/lux/data/color.Color +``` + +R:8B G:0 B:8B | dark magenta + +### dark\_olive\_green + +```clojure +library/lux/data/color.Color +``` + +R:55 G:6B B:2F | dark olive green + +### dark\_orange + +```clojure +library/lux/data/color.Color +``` + +R:FF G:8C B:0 | dark orange + +### dark\_orchid + +```clojure +library/lux/data/color.Color +``` + +R:99 G:32 B:CC | dark orchid + +### dark\_red + +```clojure +library/lux/data/color.Color +``` + +R:8B G:0 B:0 | dark red + +### dark\_salmon + +```clojure +library/lux/data/color.Color +``` + +R:E9 G:96 B:7A | dark salmon + +### dark\_sea\_green + +```clojure +library/lux/data/color.Color +``` + +R:8F G:BC B:8F | dark sea green + +### dark\_slate\_blue + +```clojure +library/lux/data/color.Color +``` + +R:48 G:3D B:8B | dark slate blue + +### dark\_slate\_gray + +```clojure +library/lux/data/color.Color +``` + +R:2F G:4F B:4F | dark slate gray + +### dark\_turquoise + +```clojure +library/lux/data/color.Color +``` + +R:0 G:CE B:D1 | dark turquoise + +### dark\_violet + +```clojure +library/lux/data/color.Color +``` + +R:94 G:0 B:D3 | dark violet + +### deep\_pink + +```clojure +library/lux/data/color.Color +``` + +R:FF G:14 B:93 | deep pink + +### deep\_sky\_blue + +```clojure +library/lux/data/color.Color +``` + +R:0 G:BF B:FF | deep sky blue + +### dim\_gray + +```clojure +library/lux/data/color.Color +``` + +R:69 G:69 B:69 | dim gray + +### dodger\_blue + +```clojure +library/lux/data/color.Color +``` + +R:1E G:90 B:FF | dodger blue + +### fire\_brick + +```clojure +library/lux/data/color.Color +``` + +R:B2 G:22 B:22 | fire brick + +### floral\_white + +```clojure +library/lux/data/color.Color +``` + +R:FF G:FA B:F0 | floral white + +### forest\_green + +```clojure +library/lux/data/color.Color +``` + +R:22 G:8B B:22 | forest green + +### fuchsia + +```clojure +library/lux/data/color.Color +``` + +R:FF G:0 B:FF | fuchsia + +### gainsboro + +```clojure +library/lux/data/color.Color +``` + +R:DC G:DC B:DC | gainsboro + +### ghost\_white + +```clojure +library/lux/data/color.Color +``` + +R:F8 G:F8 B:FF | ghost white + +### gold + +```clojure +library/lux/data/color.Color +``` + +R:FF G:D7 B:0 | gold + +### goldenrod + +```clojure +library/lux/data/color.Color +``` + +R:DA G:A5 B:20 | goldenrod + +### gray + +```clojure +library/lux/data/color.Color +``` + +R:80 G:80 B:80 | gray + +### green + +```clojure +library/lux/data/color.Color +``` + +R:0 G:80 B:0 | green + +### green\_yellow + +```clojure +library/lux/data/color.Color +``` + +R:AD G:FF B:2F | green yellow + +### honey\_dew + +```clojure +library/lux/data/color.Color +``` + +R:F0 G:FF B:F0 | honey dew + +### hot\_pink + +```clojure +library/lux/data/color.Color +``` + +R:FF G:69 B:B4 | hot pink + +### indian\_red + +```clojure +library/lux/data/color.Color +``` + +R:CD G:5C B:5C | indian red + +### indigo + +```clojure +library/lux/data/color.Color +``` + +R:4B G:0 B:82 | indigo + +### ivory + +```clojure +library/lux/data/color.Color +``` + +R:FF G:FF B:F0 | ivory + +### khaki + +```clojure +library/lux/data/color.Color +``` + +R:F0 G:E6 B:8C | khaki + +### lavender + +```clojure +library/lux/data/color.Color +``` + +R:E6 G:E6 B:FA | lavender + +### lavender\_blush + +```clojure +library/lux/data/color.Color +``` + +R:FF G:F0 B:F5 | lavender blush + +### lawn\_green + +```clojure +library/lux/data/color.Color +``` + +R:7C G:FC B:0 | lawn green + +### lemon\_chiffon + +```clojure +library/lux/data/color.Color +``` + +R:FF G:FA B:CD | lemon chiffon + +### light\_blue + +```clojure +library/lux/data/color.Color +``` + +R:AD G:D8 B:E6 | light blue + +### light\_coral + +```clojure +library/lux/data/color.Color +``` + +R:F0 G:80 B:80 | light coral + +### light\_cyan + +```clojure +library/lux/data/color.Color +``` + +R:E0 G:FF B:FF | light cyan + +### light\_goldenrod\_yellow + +```clojure +library/lux/data/color.Color +``` + +R:FA G:FA B:D2 | light goldenrod yellow + +### light\_gray + +```clojure +library/lux/data/color.Color +``` + +R:D3 G:D3 B:D3 | light gray + +### light\_green + +```clojure +library/lux/data/color.Color +``` + +R:90 G:EE B:90 | light green + +### light\_pink + +```clojure +library/lux/data/color.Color +``` + +R:FF G:B6 B:C1 | light pink + +### light\_salmon + +```clojure +library/lux/data/color.Color +``` + +R:FF G:A0 B:7A | light salmon + +### light\_sea\_green + +```clojure +library/lux/data/color.Color +``` + +R:20 G:B2 B:AA | light sea green + +### light\_sky\_blue + +```clojure +library/lux/data/color.Color +``` + +R:87 G:CE B:FA | light sky blue + +### light\_slate\_gray + +```clojure +library/lux/data/color.Color +``` + +R:77 G:88 B:99 | light slate gray + +### light\_steel\_blue + +```clojure +library/lux/data/color.Color +``` + +R:B0 G:C4 B:DE | light steel blue + +### light\_yellow + +```clojure +library/lux/data/color.Color +``` + +R:FF G:FF B:E0 | light yellow + +### lime + +```clojure +library/lux/data/color.Color +``` + +R:0 G:FF B:0 | lime + +### lime\_green + +```clojure +library/lux/data/color.Color +``` + +R:32 G:CD B:32 | lime green + +### linen + +```clojure +library/lux/data/color.Color +``` + +R:FA G:F0 B:E6 | linen + +### magenta + +```clojure +library/lux/data/color.Color +``` + +R:FF G:0 B:FF | magenta + +### maroon + +```clojure +library/lux/data/color.Color +``` + +R:80 G:0 B:0 | maroon + +### medium\_aquamarine + +```clojure +library/lux/data/color.Color +``` + +R:66 G:CD B:AA | medium aquamarine + +### medium\_blue + +```clojure +library/lux/data/color.Color +``` + +R:0 G:0 B:CD | medium blue + +### medium\_orchid + +```clojure +library/lux/data/color.Color +``` + +R:BA G:55 B:D3 | medium orchid + +### medium\_purple + +```clojure +library/lux/data/color.Color +``` + +R:93 G:70 B:DB | medium purple + +### medium\_sea\_green + +```clojure +library/lux/data/color.Color +``` + +R:3C G:B3 B:71 | medium sea green + +### medium\_slate\_blue + +```clojure +library/lux/data/color.Color +``` + +R:7B G:68 B:EE | medium slate blue + +### medium\_spring\_green + +```clojure +library/lux/data/color.Color +``` + +R:0 G:FA B:9A | medium spring green + +### medium\_turquoise + +```clojure +library/lux/data/color.Color +``` + +R:48 G:D1 B:CC | medium turquoise + +### medium\_violet\_red + +```clojure +library/lux/data/color.Color +``` + +R:C7 G:15 B:85 | medium violet red + +### midnight\_blue + +```clojure +library/lux/data/color.Color +``` + +R:19 G:19 B:70 | midnight blue + +### mint\_cream + +```clojure +library/lux/data/color.Color +``` + +R:F5 G:FF B:FA | mint cream + +### misty\_rose + +```clojure +library/lux/data/color.Color +``` + +R:FF G:E4 B:E1 | misty rose + +### moccasin + +```clojure +library/lux/data/color.Color +``` + +R:FF G:E4 B:B5 | moccasin + +### navajo\_white + +```clojure +library/lux/data/color.Color +``` + +R:FF G:DE B:AD | navajo white + +### navy + +```clojure +library/lux/data/color.Color +``` + +R:0 G:0 B:80 | navy + +### old\_lace + +```clojure +library/lux/data/color.Color +``` + +R:FD G:F5 B:E6 | old lace + +### olive + +```clojure +library/lux/data/color.Color +``` + +R:80 G:80 B:0 | olive + +### olive\_drab + +```clojure +library/lux/data/color.Color +``` + +R:6B G:8E B:23 | olive drab + +### orange + +```clojure +library/lux/data/color.Color +``` + +R:FF G:A5 B:0 | orange + +### orange\_red + +```clojure +library/lux/data/color.Color +``` + +R:FF G:45 B:0 | orange red + +### orchid + +```clojure +library/lux/data/color.Color +``` + +R:DA G:70 B:D6 | orchid + +### pale\_goldenrod + +```clojure +library/lux/data/color.Color +``` + +R:EE G:E8 B:AA | pale goldenrod + +### pale\_green + +```clojure +library/lux/data/color.Color +``` + +R:98 G:FB B:98 | pale green + +### pale\_turquoise + +```clojure +library/lux/data/color.Color +``` + +R:AF G:EE B:EE | pale turquoise + +### pale\_violet\_red + +```clojure +library/lux/data/color.Color +``` + +R:DB G:70 B:93 | pale violet red + +### papaya\_whip + +```clojure +library/lux/data/color.Color +``` + +R:FF G:EF B:D5 | papaya whip + +### peach\_puff + +```clojure +library/lux/data/color.Color +``` + +R:FF G:DA B:B9 | peach puff + +### peru + +```clojure +library/lux/data/color.Color +``` + +R:CD G:85 B:3F | peru + +### pink + +```clojure +library/lux/data/color.Color +``` + +R:FF G:C0 B:CB | pink + +### plum + +```clojure +library/lux/data/color.Color +``` + +R:DD G:A0 B:DD | plum + +### powder\_blue + +```clojure +library/lux/data/color.Color +``` + +R:B0 G:E0 B:E6 | powder blue + +### purple + +```clojure +library/lux/data/color.Color +``` + +R:80 G:0 B:80 | purple + +### rebecca\_purple + +```clojure +library/lux/data/color.Color +``` + +R:66 G:33 B:99 | rebecca purple + +### red + +```clojure +library/lux/data/color.Color +``` + +R:FF G:0 B:0 | red + +### rosy\_brown + +```clojure +library/lux/data/color.Color +``` + +R:BC G:8F B:8F | rosy brown + +### royal\_blue + +```clojure +library/lux/data/color.Color +``` + +R:41 G:69 B:E1 | royal blue + +### saddle\_brown + +```clojure +library/lux/data/color.Color +``` + +R:8B G:45 B:13 | saddle brown + +### salmon + +```clojure +library/lux/data/color.Color +``` + +R:FA G:80 B:72 | salmon + +### sandy\_brown + +```clojure +library/lux/data/color.Color +``` + +R:F4 G:A4 B:60 | sandy brown + +### sea\_green + +```clojure +library/lux/data/color.Color +``` + +R:2E G:8B B:57 | sea green + +### sea\_shell + +```clojure +library/lux/data/color.Color +``` + +R:FF G:F5 B:EE | sea shell + +### sienna + +```clojure +library/lux/data/color.Color +``` + +R:A0 G:52 B:2D | sienna + +### silver + +```clojure +library/lux/data/color.Color +``` + +R:C0 G:C0 B:C0 | silver + +### sky\_blue + +```clojure +library/lux/data/color.Color +``` + +R:87 G:CE B:EB | sky blue + +### slate\_blue + +```clojure +library/lux/data/color.Color +``` + +R:6A G:5A B:CD | slate blue + +### slate\_gray + +```clojure +library/lux/data/color.Color +``` + +R:70 G:80 B:90 | slate gray + +### snow + +```clojure +library/lux/data/color.Color +``` + +R:FF G:FA B:FA | snow + +### spring\_green + +```clojure +library/lux/data/color.Color +``` + +R:0 G:FF B:7F | spring green + +### steel\_blue + +```clojure +library/lux/data/color.Color +``` + +R:46 G:82 B:B4 | steel blue + +### tan + +```clojure +library/lux/data/color.Color +``` + +R:D2 G:B4 B:8C | tan + +### teal + +```clojure +library/lux/data/color.Color +``` + +R:0 G:80 B:80 | teal + +### thistle + +```clojure +library/lux/data/color.Color +``` + +R:D8 G:BF B:D8 | thistle + +### tomato + +```clojure +library/lux/data/color.Color +``` + +R:FF G:63 B:47 | tomato + +### turquoise + +```clojure +library/lux/data/color.Color +``` + +R:40 G:E0 B:D0 | turquoise + +### violet + +```clojure +library/lux/data/color.Color +``` + +R:EE G:82 B:EE | violet + +### wheat + +```clojure +library/lux/data/color.Color +``` + +R:F5 G:DE B:B3 | wheat + +### white + +```clojure +library/lux/data/color.Color +``` + +R:FF G:FF B:FF | white + +### white\_smoke + +```clojure +library/lux/data/color.Color +``` + +R:F5 G:F5 B:F5 | white smoke + +### yellow + +```clojure +library/lux/data/color.Color +``` + +R:FF G:FF B:0 | yellow + +### yellow\_green + +```clojure +library/lux/data/color.Color +``` + +R:9A G:CD B:32 | yellow green + +___ + +# library/lux/data/format/binary + +## Definitions + +### Mutation + +```clojure +... .Type +(-> [library/lux/control/parser/binary.Offset library/lux/data/binary.Binary] [library/lux/control/parser/binary.Offset library/lux/data/binary.Binary]) +``` + +A mutation of binary data, tracking where in the data to transform\. + +### Specification + +```clojure +... .Type +[library/lux/control/parser/binary.Size Mutation] +``` + +A description of how to transform binary data\. + +### \(Writer it\) + +```clojure +... .Type +(-> it Specification) +``` + +An operation that knows how to write information into a binary blob\. + +### and + +```clojure +(All (_ a b) (-> (Writer a) (Writer b) (Writer [a b]))) +``` + +```clojure +(and pre post) +``` + +### any + +```clojure +(Writer .Any) +``` + +### binary/16 + +```clojure +(Writer library/lux/data/binary.Binary) +``` + +### binary/32 + +```clojure +(Writer library/lux/data/binary.Binary) +``` + +### binary/64 + +```clojure +(Writer library/lux/data/binary.Binary) +``` + +### binary/8 + +```clojure +(Writer library/lux/data/binary.Binary) +``` + +### bit + +```clojure +(Writer .Bit) +``` + +### bits/16 + +```clojure +(Writer (.I64 .Any)) +``` + +### bits/32 + +```clojure +(Writer (.I64 .Any)) +``` + +### bits/64 + +```clojure +(Writer (.I64 .Any)) +``` + +### bits/8 + +```clojure +(Writer (.I64 .Any)) +``` + +### code + +```clojure +(Writer .Code) +``` + +### frac + +```clojure +(Writer .Frac) +``` + +### instance + +```clojure +(-> Specification library/lux/data/binary.Binary) +``` + +Given a specification of how to construct binary data, yields a binary blob that matches it\. + +### int + +```clojure +(Writer .Int) +``` + +### list + +```clojure +(All (_ a) (-> (Writer a) (Writer (.List a)))) +``` + +### location + +```clojure +(Writer .Location) +``` + +### maybe + +```clojure +(All (_ a) (-> (Writer a) (Writer (.Maybe a)))) +``` + +### monoid + +```clojure +(library/lux/abstract/monoid.Monoid Specification) +``` + +### name + +```clojure +(Writer .Name) +``` + +### nat + +```clojure +(Writer .Nat) +``` + +### no\_op + +```clojure +Specification +``` + +A specification for empty binary data\. + +### or + +```clojure +(All (_ a b) (-> (Writer a) (Writer b) (Writer (Or a b)))) +``` + +```clojure +(or left right) +``` + +### rec + +```clojure +(All (_ a) (-> (-> (Writer a) (Writer a)) (Writer a))) +``` + +A combinator for recursive writers\. + +```clojure +(rec body) +``` + +### result + +```clojure +(All (_ a) (-> (Writer a) a library/lux/data/binary.Binary)) +``` + +Yields a binary blob with all the information written to it\. + +```clojure +(result writer value) +``` + +### rev + +```clojure +(Writer .Rev) +``` + +### row/16 + +```clojure +(All (_ a) (-> (Writer a) (Writer (library/lux/data/collection/row.Row a)))) +``` + +### row/32 + +```clojure +(All (_ a) (-> (Writer a) (Writer (library/lux/data/collection/row.Row a)))) +``` + +### row/64 + +```clojure +(All (_ a) (-> (Writer a) (Writer (library/lux/data/collection/row.Row a)))) +``` + +### row/8 + +```clojure +(All (_ a) (-> (Writer a) (Writer (library/lux/data/collection/row.Row a)))) +``` + +### segment + +```clojure +(-> .Nat (Writer library/lux/data/binary.Binary)) +``` + +Writes at most 'size' bytes of an input binary blob\. + +```clojure +(segment size) +``` + +### set + +```clojure +(All (_ a) (-> (Writer a) (Writer (library/lux/data/collection/set.Set a)))) +``` + +### text + +```clojure +(Writer .Text) +``` + +### type + +```clojure +(Writer .Type) +``` + +### utf8/16 + +```clojure +(Writer .Text) +``` + +### utf8/32 + +```clojure +(Writer .Text) +``` + +### utf8/64 + +```clojure +(Writer .Text) +``` + +### utf8/8 + +```clojure +(Writer .Text) +``` + +## Missing documentation + +1. `` or/5 `` + +___ + +# library/lux/data/format/json + +Functionality for reading and writing values in the JSON format\. +For more information, please see: http://www\.json\.org/ + +## Definitions + +### Array + +```clojure +... .Type +(library/lux/data/collection/row.Row JSON) +``` + +### Boolean + +```clojure +... .Type +(primitive "#Bit") +``` + +### JSON + +```clojure +... .Type +((All (JSON a) (Or Null Boolean Number String (library/lux/data/collection/row.Row (JSON .Nothing)) (library/lux/data/collection/dictionary.Dictionary String (JSON .Nothing)))) .Nothing) +``` + +### Null + +```clojure +... .Type +(Ex (Null a) a) +``` + +### Number + +```clojure +... .Type +(primitive "#Frac") +``` + +### Object + +```clojure +... .Type +(library/lux/data/collection/dictionary.Dictionary String JSON) +``` + +### String + +```clojure +... .Type +(primitive "#Text") +``` + +### array\_field + +```clojure +(-> .Text JSON (library/lux/control/try.Try Array)) +``` + +A JSON object field getter for arrays\. + +```clojure + ( + + + + +array_field key json) +``` + +### boolean\_field + +```clojure +(-> .Text JSON (library/lux/control/try.Try Boolean)) +``` + +A JSON object field getter for booleans\. + +```clojure + ( + +boolean_field key json) +``` + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text JSON) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence JSON) +``` + +### field + +```clojure +(-> String JSON (library/lux/control/try.Try JSON)) +``` + +A JSON object field getter\. + +```clojure +(field key json) +``` + +### fields + +```clojure +(-> JSON (library/lux/control/try.Try (.List String))) +``` + +Get all the fields in a JSON object\. + +```clojure +(fields json) +``` + +### format + +```clojure +(-> JSON .Text) +``` + +### has + +```clojure +(-> String JSON JSON (library/lux/control/try.Try JSON)) +``` + +A JSON object field setter\. + +```clojure +(has key value json) +``` + +### json + +```clojure +.Macro +``` + +A simple way to produce JSON literals\. + +```clojure +(json #null) + +................................................................ +................................................................ + +(json #1) + +................................................................ +................................................................ + +(json +123.456) + +................................................................ +................................................................ + +(json "this is a string") + +................................................................ +................................................................ + +(json ["this" "is" "an" "array"]) + +................................................................ +................................................................ + +(json {"this" "is" + "an" "object"}) +``` + +### null? + +```clojure +(library/lux/abstract/predicate.Predicate JSON) +``` + +### number\_field + +```clojure +(-> .Text JSON (library/lux/control/try.Try Number)) +``` + +A JSON object field getter for numbers\. + +```clojure + ( + + +number_field key json) +``` + +### object + +```clojure +(-> (.List [String JSON]) JSON) +``` + +### object\_field + +```clojure +(-> .Text JSON (library/lux/control/try.Try Object)) +``` + +A JSON object field getter for objects\. + +```clojure + ( + + + + + +object_field key json) +``` + +### string\_field + +```clojure +(-> .Text JSON (library/lux/control/try.Try String)) +``` + +A JSON object field getter for strings\. + +```clojure + ( + + + +string_field key json) +``` + +___ + +# library/lux/data/format/tar + +## Definitions + +### Big + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Big") +``` + +### Content + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Content") +``` + +### Contiguous + +```clojure +... .Type +[Path library/lux/time/instant.Instant Mode Ownership Content] +``` + +### Directory + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Path") +``` + +### Entry + +```clojure +... .Type +(Or Normal Symbolic_Link Directory Contiguous) +``` + +### File + +```clojure +... .Type +[Path library/lux/time/instant.Instant Mode Ownership Content] +``` + +### ID + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Small") +``` + +### Mode + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Mode") +``` + +### Name + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Name") +``` + +### Normal + +```clojure +... .Type +[Path library/lux/time/instant.Instant Mode Ownership Content] +``` + +### Owner + +```clojure +... .Type +[Name ID] +``` + +### Ownership + +```clojure +... .Type +[Owner Owner] +``` + +### Path + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Path") +``` + +### Small + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Small") +``` + +### Symbolic\_Link + +```clojure +... .Type +(primitive "library/lux/data/format/tar.Path") +``` + +### Tar + +```clojure +... .Type +(library/lux/data/collection/row.Row Entry) +``` + +### and + +```clojure +(-> Mode Mode Mode) +``` + +### anonymous + +```clojure +Name +``` + +### big + +```clojure +(-> .Nat (library/lux/control/try.Try Big)) +``` + +### big\_limit + +```clojure +.Nat +``` + +### content + +```clojure +(-> library/lux/data/binary.Binary (library/lux/control/try.Try Content)) +``` + +### data + +```clojure +(-> Content library/lux/data/binary.Binary) +``` + +### execute\_by\_group + +```clojure +Mode +``` + +### execute\_by\_other + +```clojure +Mode +``` + +### execute\_by\_owner + +```clojure +Mode +``` + +### from\_big + +```clojure +(-> Big .Nat) +``` + +### from\_name + +```clojure +(-> Name .Text) +``` + +### from\_path + +```clojure +(-> Path library/lux/world/file.Path) +``` + +### from\_small + +```clojure +(-> Small .Nat) +``` + +### invalid\_end\_of\_archive + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### invalid\_link\_flag + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### invalid\_mode + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### mode + +```clojure +(-> Mode .Nat) +``` + +### name + +```clojure +(-> .Text (library/lux/control/try.Try Name)) +``` + +### name\_is\_too\_long + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### name\_size + +```clojure +Size +``` + +### no\_id + +```clojure +ID +``` + +### no\_path + +```clojure +Path +``` + +### none + +```clojure +Mode +``` + +### not\_a\_big\_number + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### not\_a\_small\_number + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### not\_ascii + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### parser + +```clojure +(library/lux/control/parser/binary.Parser Tar) +``` + +### path + +```clojure +(-> library/lux/world/file.Path (library/lux/control/try.Try Path)) +``` + +### path\_is\_too\_long + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### path\_size + +```clojure +Size +``` + +### read\_by\_group + +```clojure +Mode +``` + +### read\_by\_other + +```clojure +Mode +``` + +### read\_by\_owner + +```clojure +Mode +``` + +### save\_text + +```clojure +Mode +``` + +### set\_group\_id\_on\_execution + +```clojure +Mode +``` + +### set\_user\_id\_on\_execution + +```clojure +Mode +``` + +### small + +```clojure +(-> .Nat (library/lux/control/try.Try Small)) +``` + +### small\_limit + +```clojure +.Nat +``` + +### write\_by\_group + +```clojure +Mode +``` + +### write\_by\_other + +```clojure +Mode +``` + +### write\_by\_owner + +```clojure +Mode +``` + +### writer + +```clojure +(library/lux/data/format/binary.Writer Tar) +``` + +### wrong\_character + +```clojure +(library/lux/control/exception.Exception [library/lux/data/text.Char library/lux/data/text.Char]) +``` + +### wrong\_checksum + +```clojure +(library/lux/control/exception.Exception [.Nat .Nat]) +``` + +### wrong\_link\_flag + +```clojure +(library/lux/control/exception.Exception [Link_Flag Link_Flag]) +``` + +___ + +# library/lux/data/format/xml + +## Definitions + +### Attribute + +```clojure +... .Type +[.Text .Text] +``` + +### Attrs + +```clojure +... .Type +(library/lux/data/collection/dictionary.Dictionary Attribute .Text) +``` + +### Tag + +```clojure +... .Type +[.Text .Text] +``` + +### XML + +```clojure +... .Type +((All (XML a) (Or .Text [Tag Attrs (.List (XML .Nothing))])) .Nothing) +``` + +### attribute + +```clojure +(-> Attribute .Text) +``` + +The text format of a XML attribute\. + +### attributes + +```clojure +Attrs +``` + +An empty set of XML attributes\. + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text XML) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence XML) +``` + +### tag + +```clojure +(-> Tag .Text) +``` + +The text format of a XML tag\. + +```clojure +(tag name) +``` + +___ + +# library/lux/data/identity + +## Definitions + +### \(Identity it\) + +```clojure +... .Type +it +``` + +A value, as is, without any extra structure super\-imposed on it\. + +### apply + +```clojure +(library/lux/abstract/apply.Apply Identity) +``` + +### comonad + +```clojure +(library/lux/abstract/comonad.CoMonad Identity) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Identity) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Identity) +``` + +___ + +# library/lux/data/name + +## Definitions + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text .Name) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Name) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash .Name) +``` + +### module + +```clojure +(-> .Name .Text) +``` + +The module part of a name\. + +### order + +```clojure +(library/lux/abstract/order.Order .Name) +``` + +### short + +```clojure +(-> .Name .Text) +``` + +The short part of a name\. + +___ + +# library/lux/data/product + +Functionality for working with tuples \(particularly 2\-tuples/pairs\)\. + +## Definitions + +### curried + +```clojure +(All (_ a b c) (-> (-> [a b] c) a b c)) +``` + +Converts a 2\-argument function into nested single\-argument functions\. + +```clojure +(curried f) +``` + +### equivalence + +```clojure +(All (_ a b) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence b) (library/lux/abstract/equivalence.Equivalence [a b]))) +``` + +### forked + +```clojure +(All (_ a b c) (-> (-> a b) (-> a c) a [b c])) +``` + +Yields a pair by applying both functions to a single value\. + +```clojure +(forked f g) +``` + +### hash + +```clojure +(All (_ a b) (-> (library/lux/abstract/hash.Hash a) (library/lux/abstract/hash.Hash b) (library/lux/abstract/hash.Hash [a b]))) +``` + +### left + +```clojure +(All (_ a b) (-> [a b] a)) +``` + +The left side of a pair\. + +### right + +```clojure +(All (_ a b) (-> [a b] b)) +``` + +The right side of a pair\. + +### swapped + +```clojure +(All (_ a b) (-> [a b] [b a])) +``` + +```clojure +(swapped [left right]) +``` + +### then + +```clojure +(All (_ a b c d) (-> (-> a c) (-> b d) [a b] [c d])) +``` + +Apply functions to both sides of a pair\. + +```clojure +(then f g) +``` + +### uncurried + +```clojure +(All (_ a b c) (-> (-> a b c) [a b] c)) +``` + +Converts nested single\-argument functions into a 2\-argument function\. + +```clojure +(uncurried f) +``` + +___ + +# library/lux/data/sum + +Functionality for working with variants \(particularly 2\-variants\)\. + +## Definitions + +### either + +```clojure +(All (_ a b c) (-> (-> a c) (-> b c) (Or a b) c)) +``` + +Applies a function to either side of a 2\-variant\. + +```clojure +(either on_left on_right) +``` + +### equivalence + +```clojure +(All (_ a b) (-> (library/lux/abstract/equivalence.Equivalence a) (library/lux/abstract/equivalence.Equivalence b) (library/lux/abstract/equivalence.Equivalence (Or a b)))) +``` + +### hash + +```clojure +(All (_ a b) (-> (library/lux/abstract/hash.Hash a) (library/lux/abstract/hash.Hash b) (library/lux/abstract/hash.Hash (Or a b)))) +``` + +### left + +```clojure +(All (_ a b) (-> a (Or a b))) +``` + +Lifts value to the left side of a 2\-variant\. + +### lefts + +```clojure +(All (_ a b) (-> (.List (Or a b)) (.List a))) +``` + +### partition + +```clojure +(All (_ a b) (-> (.List (Or a b)) [(.List a) (.List b)])) +``` + +### right + +```clojure +(All (_ a b) (-> b (Or a b))) +``` + +Lifts value to the right side of a 2\-variant\. + +### rights + +```clojure +(All (_ a b) (-> (.List (Or a b)) (.List b))) +``` + +### then + +```clojure +(All (_ a b c d) (-> (-> a b) (-> c d) (Or a c) (Or b d))) +``` + +Applies functions to both sides of a 2\-variant\. + +```clojure +(then on_left on_right) +``` + +___ + +# library/lux/data/text + +## Definitions + +### Char + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +A character code number\. + +### \\'' + +```clojure +.Text +``` + +### \\0 + +```clojure +.Text +``` + +### \\a + +```clojure +.Text +``` + +### \\b + +```clojure +.Text +``` + +### \\f + +```clojure +.Text +``` + +### \\n + +```clojure +.Text +``` + +### \\r + +```clojure +.Text +``` + +### \\t + +```clojure +.Text +``` + +### \\v + +```clojure +.Text +``` + +### alarm + +```clojure +.Text +``` + +### all\_split\_by + +```clojure +(-> .Text .Text (.List .Text)) +``` + +```clojure +(all_split_by token sample) +``` + +### back\_space + +```clojure +.Text +``` + +### carriage\_return + +```clojure +.Text +``` + +### char + +```clojure +(-> .Nat .Text (.Maybe Char)) +``` + +Yields the character at the specified index\. + +```clojure +(char index input) +``` + +### clip + +```clojure +(-> .Nat .Nat .Text (.Maybe .Text)) +``` + +Clips a chunk of text from the input at the specified offset and of the specified size\. + +```clojure +(clip offset size input) +``` + +### clip\_since + +```clojure +(-> .Nat .Text (.Maybe .Text)) +``` + +Clips the remaining text from the input at the specified offset\. + +```clojure +(clip_since offset input) +``` + +### contains? + +```clojure +(-> .Text .Text .Bit) +``` + +```clojure +(contains? sub text) +``` + +### double\_quote + +```clojure +.Text +``` + +### empty? + +```clojure +(-> .Text .Bit) +``` + +### enclosed + +```clojure +(-> [.Text .Text] .Text .Text) +``` + +Surrounds the given content text with left and right side additions\. + +```clojure +(enclosed [left right] content) +``` + +### enclosed' + +```clojure +(-> .Text .Text .Text) +``` + +Surrounds the given content text with the same boundary text\. + +```clojure +(enclosed' boundary content) +``` + +### enclosed\_by? + +```clojure +(-> .Text .Text .Bit) +``` + +```clojure +(enclosed_by? boundary value) +``` + +### ends\_with? + +```clojure +(-> .Text .Text .Bit) +``` + +```clojure +(ends_with? postfix x) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Text) +``` + +### form\_feed + +```clojure +.Text +``` + +### format + +```clojure +(-> .Text .Text) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash .Text) +``` + +### index + +```clojure +(-> .Text .Text (.Maybe .Nat)) +``` + +```clojure +(index pattern input) +``` + +### index\_since + +```clojure +(-> .Nat .Text .Text (.Maybe .Nat)) +``` + +```clojure +(index_since from pattern input) +``` + +### interposed + +```clojure +(-> .Text (.List .Text) .Text) +``` + +```clojure +(interposed separator texts) +``` + +### last\_index + +```clojure +(-> .Text .Text (.Maybe .Nat)) +``` + +```clojure +(last_index part text) +``` + +### line\_feed + +```clojure +.Text +``` + +Same as 'new\_line'\. + +### lower\_cased + +```clojure +(-> .Text .Text) +``` + +### monoid + +```clojure +(library/lux/abstract/monoid.Monoid .Text) +``` + +### new\_line + +```clojure +.Text +``` + +### null + +```clojure +.Text +``` + +### of\_char + +```clojure +(-> Char .Text) +``` + +### order + +```clojure +(library/lux/abstract/order.Order .Text) +``` + +### prefix + +```clojure +(-> .Text .Text .Text) +``` + +```clojure +(prefix param subject) +``` + +### replaced + +```clojure +(-> .Text .Text .Text .Text) +``` + +```clojure +(replaced pattern replacement template) +``` + +### replaced/1 + +```clojure +(-> .Text .Text .Text .Text) +``` + +```clojure +(replaced/1 pattern replacement template) +``` + +### size + +```clojure +(-> .Text .Nat) +``` + +### space + +```clojure +.Text +``` + +### space? + +```clojure +(-> Char .Bit) +``` + +Checks whether the character is white\-space\. + +```clojure +(space? char) +``` + +### split\_at + +```clojure +(-> .Nat .Text (.Maybe [.Text .Text])) +``` + +```clojure +(split_at at x) +``` + +### split\_by + +```clojure +(-> .Text .Text (.Maybe [.Text .Text])) +``` + +```clojure +(split_by token sample) +``` + +### starts\_with? + +```clojure +(-> .Text .Text .Bit) +``` + +```clojure +(starts_with? prefix x) +``` + +### suffix + +```clojure +(-> .Text .Text .Text) +``` + +```clojure +(suffix param subject) +``` + +### tab + +```clojure +.Text +``` + +### together + +```clojure +(-> (.List .Text) .Text) +``` + +### upper\_cased + +```clojure +(-> .Text .Text) +``` + +### vertical\_tab + +```clojure +.Text +``` + +___ + +# library/lux/data/text/buffer + +## Definitions + +### Buffer + +```clojure +... .Type +(primitive "library/lux/data/text/buffer.Buffer") +``` + +Immutable text buffer for efficient text concatenation\. + +### empty + +```clojure +Buffer +``` + +### size + +```clojure +(-> Buffer .Nat) +``` + +### text + +```clojure +(-> Buffer .Text) +``` + +### then + +```clojure +(-> .Text Buffer Buffer) +``` + +___ + +# library/lux/data/text/encoding + +## Definitions + +### Encoding + +```clojure +... .Type +(primitive "library/lux/data/text/encoding.Encoding") +``` + +Encoding formats for text\. + +### ascii + +```clojure +Encoding +``` + +'ASCII' text encoding\. + +### cesu\_8 + +```clojure +Encoding +``` + +'CESU\-8' text encoding\. + +### ibm\_037 + +```clojure +Encoding +``` + +'IBM037' text encoding\. + +### ibm\_1006 + +```clojure +Encoding +``` + +'IBM1006' text encoding\. + +### ibm\_1025 + +```clojure +Encoding +``` + +'IBM1025' text encoding\. + +### ibm\_1026 + +```clojure +Encoding +``` + +'IBM1026' text encoding\. + +### ibm\_1046 + +```clojure +Encoding +``` + +'IBM1046' text encoding\. + +### ibm\_1047 + +```clojure +Encoding +``` + +'IBM1047' text encoding\. + +### ibm\_1097 + +```clojure +Encoding +``` + +'IBM1097' text encoding\. + +### ibm\_1098 + +```clojure +Encoding +``` + +'IBM1098' text encoding\. + +### ibm\_1112 + +```clojure +Encoding +``` + +'IBM1112' text encoding\. + +### ibm\_1122 + +```clojure +Encoding +``` + +'IBM1122' text encoding\. + +### ibm\_1123 + +```clojure +Encoding +``` + +'IBM1123' text encoding\. + +### ibm\_1124 + +```clojure +Encoding +``` + +'IBM1124' text encoding\. + +### ibm\_1140 + +```clojure +Encoding +``` + +'IBM01140' text encoding\. + +### ibm\_1141 + +```clojure +Encoding +``` + +'IBM01141' text encoding\. + +### ibm\_1142 + +```clojure +Encoding +``` + +'IBM01142' text encoding\. + +### ibm\_1143 + +```clojure +Encoding +``` + +'IBM01143' text encoding\. + +### ibm\_1144 + +```clojure +Encoding +``` + +'IBM01144' text encoding\. + +### ibm\_1145 + +```clojure +Encoding +``` + +'IBM01145' text encoding\. + +### ibm\_1146 + +```clojure +Encoding +``` + +'IBM01146' text encoding\. + +### ibm\_1147 + +```clojure +Encoding +``` + +'IBM01147' text encoding\. + +### ibm\_1148 + +```clojure +Encoding +``` + +'IBM01148' text encoding\. + +### ibm\_1149 + +```clojure +Encoding +``` + +'IBM01149' text encoding\. + +### ibm\_1166 + +```clojure +Encoding +``` + +'IBM1166' text encoding\. + +### ibm\_1364 + +```clojure +Encoding +``` + +'IBM1364' text encoding\. + +### ibm\_1381 + +```clojure +Encoding +``` + +'IBM1381' text encoding\. + +### ibm\_1383 + +```clojure +Encoding +``` + +'IBM1383' text encoding\. + +### ibm\_273 + +```clojure +Encoding +``` + +'IBM273' text encoding\. + +### ibm\_277 + +```clojure +Encoding +``` + +'IBM277' text encoding\. + +### ibm\_278 + +```clojure +Encoding +``` + +'IBM278' text encoding\. + +### ibm\_280 + +```clojure +Encoding +``` + +'IBM280' text encoding\. + +### ibm\_284 + +```clojure +Encoding +``` + +'IBM284' text encoding\. + +### ibm\_285 + +```clojure +Encoding +``` + +'IBM285' text encoding\. + +### ibm\_290 + +```clojure +Encoding +``` + +'IBM290' text encoding\. + +### ibm\_297 + +```clojure +Encoding +``` + +'IBM297' text encoding\. + +### ibm\_300 + +```clojure +Encoding +``` + +'IBM300' text encoding\. + +### ibm\_33722 + +```clojure +Encoding +``` + +'IBM33722' text encoding\. + +### ibm\_420 + +```clojure +Encoding +``` + +'IBM420' text encoding\. + +### ibm\_424 + +```clojure +Encoding +``` + +'IBM424' text encoding\. + +### ibm\_437 + +```clojure +Encoding +``` + +'IBM437' text encoding\. + +### ibm\_500 + +```clojure +Encoding +``` + +'IBM500' text encoding\. + +### ibm\_737 + +```clojure +Encoding +``` + +'IBM737' text encoding\. + +### ibm\_775 + +```clojure +Encoding +``` + +'IBM775' text encoding\. + +### ibm\_833 + +```clojure +Encoding +``` + +'IBM833' text encoding\. + +### ibm\_834 + +```clojure +Encoding +``` + +'IBM834' text encoding\. + +### ibm\_838 + +```clojure +Encoding +``` + +'IBM\-Thai' text encoding\. + +### ibm\_850 + +```clojure +Encoding +``` + +'IBM850' text encoding\. + +### ibm\_852 + +```clojure +Encoding +``` + +'IBM852' text encoding\. + +### ibm\_855 + +```clojure +Encoding +``` + +'IBM855' text encoding\. + +### ibm\_856 + +```clojure +Encoding +``` + +'IBM856' text encoding\. + +### ibm\_857 + +```clojure +Encoding +``` + +'IBM857' text encoding\. + +### ibm\_858 + +```clojure +Encoding +``` + +'IBM00858' text encoding\. + +### ibm\_860 + +```clojure +Encoding +``` + +'IBM860' text encoding\. + +### ibm\_861 + +```clojure +Encoding +``` + +'IBM861' text encoding\. + +### ibm\_862 + +```clojure +Encoding +``` + +'IBM862' text encoding\. + +### ibm\_863 + +```clojure +Encoding +``` + +'IBM863' text encoding\. + +### ibm\_864 + +```clojure +Encoding +``` + +'IBM864' text encoding\. + +### ibm\_865 + +```clojure +Encoding +``` + +'IBM865' text encoding\. + +### ibm\_866 + +```clojure +Encoding +``` + +'IBM866' text encoding\. + +### ibm\_868 + +```clojure +Encoding +``` + +'IBM868' text encoding\. + +### ibm\_869 + +```clojure +Encoding +``` + +'IBM869' text encoding\. + +### ibm\_870 + +```clojure +Encoding +``` + +'IBM870' text encoding\. + +### ibm\_871 + +```clojure +Encoding +``` + +'IBM871' text encoding\. + +### ibm\_874 + +```clojure +Encoding +``` + +'IBM874' text encoding\. + +### ibm\_875 + +```clojure +Encoding +``` + +'IBM875' text encoding\. + +### ibm\_918 + +```clojure +Encoding +``` + +'IBM918' text encoding\. + +### ibm\_921 + +```clojure +Encoding +``` + +'IBM921' text encoding\. + +### ibm\_922 + +```clojure +Encoding +``` + +'IBM922' text encoding\. + +### ibm\_930 + +```clojure +Encoding +``` + +'IBM930' text encoding\. + +### ibm\_933 + +```clojure +Encoding +``` + +'IBM933' text encoding\. + +### ibm\_935 + +```clojure +Encoding +``` + +'IBM935' text encoding\. + +### ibm\_937 + +```clojure +Encoding +``` + +'IBM937' text encoding\. + +### ibm\_939 + +```clojure +Encoding +``` + +'IBM939' text encoding\. + +### ibm\_942 + +```clojure +Encoding +``` + +'IBM942' text encoding\. + +### ibm\_942c + +```clojure +Encoding +``` + +'IBM942C' text encoding\. + +### ibm\_943 + +```clojure +Encoding +``` + +'IBM943' text encoding\. + +### ibm\_943c + +```clojure +Encoding +``` + +'IBM943C' text encoding\. + +### ibm\_948 + +```clojure +Encoding +``` + +'IBM948' text encoding\. + +### ibm\_949 + +```clojure +Encoding +``` + +'IBM949' text encoding\. + +### ibm\_949c + +```clojure +Encoding +``` + +'IBM949C' text encoding\. + +### ibm\_950 + +```clojure +Encoding +``` + +'IBM950' text encoding\. + +### ibm\_964 + +```clojure +Encoding +``` + +'IBM964' text encoding\. + +### ibm\_970 + +```clojure +Encoding +``` + +'IBM970' text encoding\. + +### iso2022\_cn\_cns + +```clojure +Encoding +``` + +'ISO2022\-CN\-CNS' text encoding\. + +### iso2022\_cn\_gb + +```clojure +Encoding +``` + +'ISO2022\-CN\-GB' text encoding\. + +### iso\_2022\_cn + +```clojure +Encoding +``` + +'ISO\-2022\-CN' text encoding\. + +### iso\_2022\_jp + +```clojure +Encoding +``` + +'ISO\-2022\-JP' text encoding\. + +### iso\_2022\_jp\_2 + +```clojure +Encoding +``` + +'ISO\-2022\-JP\-2' text encoding\. + +### iso\_2022\_kr + +```clojure +Encoding +``` + +'ISO\-2022\-KR' text encoding\. + +### iso\_8859\_1 + +```clojure +Encoding +``` + +'ISO\-8859\-1' text encoding\. + +### iso\_8859\_11 + +```clojure +Encoding +``` + +'iso\-8859\-11' text encoding\. + +### iso\_8859\_13 + +```clojure +Encoding +``` + +'ISO\-8859\-13' text encoding\. + +### iso\_8859\_15 + +```clojure +Encoding +``` + +'ISO\-8859\-15' text encoding\. + +### iso\_8859\_2 + +```clojure +Encoding +``` + +'ISO\-8859\-2' text encoding\. + +### iso\_8859\_3 + +```clojure +Encoding +``` + +'ISO\-8859\-3' text encoding\. + +### iso\_8859\_4 + +```clojure +Encoding +``` + +'ISO\-8859\-4' text encoding\. + +### iso\_8859\_5 + +```clojure +Encoding +``` + +'ISO\-8859\-5' text encoding\. + +### iso\_8859\_6 + +```clojure +Encoding +``` + +'ISO\-8859\-6' text encoding\. + +### iso\_8859\_7 + +```clojure +Encoding +``` + +'ISO\-8859\-7' text encoding\. + +### iso\_8859\_8 + +```clojure +Encoding +``` + +'ISO\-8859\-8' text encoding\. + +### iso\_8859\_9 + +```clojure +Encoding +``` + +'ISO\-8859\-9' text encoding\. + +### koi8\_r + +```clojure +Encoding +``` + +'KOI8\-R' text encoding\. + +### koi8\_u + +```clojure +Encoding +``` + +'KOI8\-U' text encoding\. + +### mac\_arabic + +```clojure +Encoding +``` + +'MacArabic' text encoding\. + +### mac\_central\_europe + +```clojure +Encoding +``` + +'MacCentralEurope' text encoding\. + +### mac\_croatian + +```clojure +Encoding +``` + +'MacCroatian' text encoding\. + +### mac\_cyrillic + +```clojure +Encoding +``` + +'MacCyrillic' text encoding\. + +### mac\_dingbat + +```clojure +Encoding +``` + +'MacDingbat' text encoding\. + +### mac\_greek + +```clojure +Encoding +``` + +'MacGreek' text encoding\. + +### mac\_hebrew + +```clojure +Encoding +``` + +'MacHebrew' text encoding\. + +### mac\_iceland + +```clojure +Encoding +``` + +'MacIceland' text encoding\. + +### mac\_roman + +```clojure +Encoding +``` + +'MacRoman' text encoding\. + +### mac\_romania + +```clojure +Encoding +``` + +'MacRomania' text encoding\. + +### mac\_symbol + +```clojure +Encoding +``` + +'MacSymbol' text encoding\. + +### mac\_thai + +```clojure +Encoding +``` + +'MacThai' text encoding\. + +### mac\_turkish + +```clojure +Encoding +``` + +'MacTurkish' text encoding\. + +### mac\_ukraine + +```clojure +Encoding +``` + +'MacUkraine' text encoding\. + +### name + +```clojure +(-> Encoding .Text) +``` + +### utf\_16 + +```clojure +Encoding +``` + +'UTF\-16' text encoding\. + +### utf\_32 + +```clojure +Encoding +``` + +'UTF\-32' text encoding\. + +### utf\_8 + +```clojure +Encoding +``` + +'UTF\-8' text encoding\. + +### windows\_1250 + +```clojure +Encoding +``` + +'windows\-1250' text encoding\. + +### windows\_1251 + +```clojure +Encoding +``` + +'windows\-1251' text encoding\. + +### windows\_1252 + +```clojure +Encoding +``` + +'windows\-1252' text encoding\. + +### windows\_1253 + +```clojure +Encoding +``` + +'windows\-1253' text encoding\. + +### windows\_1254 + +```clojure +Encoding +``` + +'windows\-1254' text encoding\. + +### windows\_1255 + +```clojure +Encoding +``` + +'windows\-1255' text encoding\. + +### windows\_1256 + +```clojure +Encoding +``` + +'windows\-1256' text encoding\. + +### windows\_1257 + +```clojure +Encoding +``` + +'windows\-1257' text encoding\. + +### windows\_1258 + +```clojure +Encoding +``` + +'windows\-1258' text encoding\. + +### windows\_31j + +```clojure +Encoding +``` + +'windows\-31j' text encoding\. + +### windows\_50220 + +```clojure +Encoding +``` + +'windows\-50220' text encoding\. + +### windows\_50221 + +```clojure +Encoding +``` + +'windows\-50221' text encoding\. + +### windows\_874 + +```clojure +Encoding +``` + +'windows\-874' text encoding\. + +### windows\_949 + +```clojure +Encoding +``` + +'windows\-949' text encoding\. + +### windows\_950 + +```clojure +Encoding +``` + +'windows\-950' text encoding\. + +### windows\_iso2022jp + +```clojure +Encoding +``` + +'windows\-iso2022jp' text encoding\. + +___ + +# library/lux/data/text/encoding/utf8 + +## Definitions + +### codec + +```clojure +(library/lux/abstract/codec.Codec library/lux/data/binary.Binary .Text) +``` + +A codec for binary encoding of text as UTF\-8\. + +___ + +# library/lux/data/text/escape + +## Definitions + +### dangling\_escape + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### escapable? + +```clojure +(-> library/lux/data/text.Char .Bit) +``` + +### escaped + +```clojure +(-> .Text .Text) +``` + +Yields a escaped version of the text\. + +```clojure +(escaped text) +``` + +### invalid\_escape + +```clojure +(library/lux/control/exception.Exception [.Text .Nat library/lux/data/text.Char]) +``` + +### invalid\_unicode\_escape + +```clojure +(library/lux/control/exception.Exception [.Text .Nat]) +``` + +### literal + +```clojure +.Macro +``` + +If given a escaped text literal, expands to an un\-escaped version\. + +```clojure +(literal "Line 1\nLine 2") + +... => + +(format "Line 1" \n + "Line 2") +``` + +### un\_escaped + +```clojure +(-> .Text (library/lux/control/try.Try .Text)) +``` + +Yields an un\-escaped text\. +Fails if it was improperly escaped\. + +```clojure +(un_escaped text) +``` + +___ + +# library/lux/data/text/format + +## Definitions + +### \(Format it\) + +```clojure +... .Type +(-> it .Text) +``` + +A way to produce readable text from values\. + +### bit + +```clojure +(Format .Bit) +``` + +### code + +```clojure +(Format .Code) +``` + +### date + +```clojure +(Format library/lux/time/date.Date) +``` + +### day + +```clojure +(Format library/lux/time/day.Day) +``` + +### duration + +```clojure +(Format library/lux/time/duration.Duration) +``` + +### format + +```clojure +.Macro +``` + +Text interpolation\. + +```clojure +(format "Static part " (text static) " does not match URI: " uri) +``` + +### frac + +```clojure +(Format .Frac) +``` + +### frac/10 + +```clojure +(Format .Frac) +``` + +### frac/16 + +```clojure +(Format .Frac) +``` + +### frac/2 + +```clojure +(Format .Frac) +``` + +### frac/8 + +```clojure +(Format .Frac) +``` + +### functor + +```clojure +(library/lux/abstract/functor/contravariant.Functor Format) +``` + +### instant + +```clojure +(Format library/lux/time/instant.Instant) +``` + +### int + +```clojure +(Format .Int) +``` + +### int/10 + +```clojure +(Format .Int) +``` + +### int/16 + +```clojure +(Format .Int) +``` + +### int/2 + +```clojure +(Format .Int) +``` + +### int/8 + +```clojure +(Format .Int) +``` + +### json + +```clojure +(Format library/lux/data/format/json.JSON) +``` + +### list + +```clojure +(All (_ a) (-> (Format a) (Format (.List a)))) +``` + +### location + +```clojure +(Format .Location) +``` + +### maybe + +```clojure +(All (_ a) (-> (Format a) (Format (.Maybe a)))) +``` + +### mod + +```clojure +(All (_ a) (Format (library/lux/math/modular.Mod a))) +``` + +### month + +```clojure +(Format library/lux/time/month.Month) +``` + +### name + +```clojure +(Format .Name) +``` + +### nat + +```clojure +(Format .Nat) +``` + +### nat/10 + +```clojure +(Format .Nat) +``` + +### nat/16 + +```clojure +(Format .Nat) +``` + +### nat/2 + +```clojure +(Format .Nat) +``` + +### nat/8 + +```clojure +(Format .Nat) +``` + +### ratio + +```clojure +(Format library/lux/math/number/ratio.Ratio) +``` + +### rev + +```clojure +(Format .Rev) +``` + +### rev/10 + +```clojure +(Format .Rev) +``` + +### rev/16 + +```clojure +(Format .Rev) +``` + +### rev/2 + +```clojure +(Format .Rev) +``` + +### rev/8 + +```clojure +(Format .Rev) +``` + +### text + +```clojure +(Format .Text) +``` + +### time + +```clojure +(Format library/lux/time.Time) +``` + +### type + +```clojure +(Format .Type) +``` + +### xml + +```clojure +(Format library/lux/data/format/xml.XML) +``` + +___ + +# library/lux/data/text/regex + +## Definitions + +### ^regex + +```clojure +.Macro +``` + +Allows you to test text against regular expressions\. + +```clojure +(case some_text + (^regex "(\d{3})-(\d{3})-(\d{4})" + [_ country_code area_code place_code]) + do_some_thing_when_number + + (^regex "\w+") + do_some_thing_when_word + + _ + do_something_else) +``` + +### incorrect\_quantification + +```clojure +(library/lux/control/exception.Exception [.Nat .Nat]) +``` + +### regex + +```clojure +.Macro +``` + +Create lexers using regular\-expression syntax\. + +```clojure +... Literals + +(regex "a") + +................................................................ +................................................................ + +... Wildcards + +(regex ".") + +................................................................ +................................................................ + +... Escaping + +(regex "\.") + +................................................................ +................................................................ + +... Character classes + +(regex "\d") + +(regex "\p{Lower}") + +(regex "[abc]") + +(regex "[a-z]") + +(regex "[a-zA-Z]") + +(regex "[a-z&&[def]]") + +................................................................ +................................................................ + +... Negation + +(regex "[^abc]") + +(regex "[^a-z]") + +(regex "[^a-zA-Z]") + +(regex "[a-z&&[^bc]]") + +(regex "[a-z&&[^m-p]]") + +................................................................ +................................................................ + +... Combinations + +(regex "aa") + +(regex "a?") + +(regex "a*") + +(regex "a+") + +................................................................ +................................................................ + +... Specific amounts + +(regex "a{2}") + +................................................................ +................................................................ + +... At least + +(regex "a{1,}") + +................................................................ +................................................................ + +... At most + +(regex "a{,1}") + +................................................................ +................................................................ + +... Between + +(regex "a{1,2}") + +................................................................ +................................................................ + +... Groups + +(regex "a(.)c") + +(regex "a(b+)c") + +(regex "(\d{3})-(\d{3})-(\d{4})") + +(regex "(\d{3})-(?:\d{3})-(\d{4})") + +(regex "(?<code>\d{3})-\k<code>-(\d{4})") + +(regex "(?<code>\d{3})-\k<code>-(\d{4})-\0") + +(regex "(\d{3})-((\d{3})-(\d{4}))") + +................................................................ +................................................................ + +... Alternation + +(regex "a|b") + +(regex "a(.)(.)|b(.)(.)") +``` + +___ + +# library/lux/data/text/unicode/block + +## Definitions + +### Block + +```clojure +... .Type +(primitive "library/lux/data/text/unicode/block.Block") +``` + +A block of valid unicode characters\. + +### alphabetic\_presentation\_forms + +```clojure +Block +``` + +FB00\-FB4F | alphabetic presentation forms + +### arabic + +```clojure +Block +``` + +600\-6FF | arabic + +### arabic\_presentation\_forms\_a + +```clojure +Block +``` + +FB50\-FDFF | arabic presentation forms a + +### arabic\_presentation\_forms\_b + +```clojure +Block +``` + +FE70\-FEFF | arabic presentation forms b + +### armenian + +```clojure +Block +``` + +530\-58F | armenian + +### arrows + +```clojure +Block +``` + +2190\-21FF | arrows + +### basic\_latin + +```clojure +Block +``` + +0\-7F | basic latin + +### basic\_latin/decimal + +```clojure +Block +``` + +30\-39 | basic latin/decimal + +### basic\_latin/lower + +```clojure +Block +``` + +61\-7A | basic latin/lower + +### basic\_latin/upper + +```clojure +Block +``` + +41\-5A | basic latin/upper + +### bengali + +```clojure +Block +``` + +980\-9FF | bengali + +### block + +```clojure +(-> library/lux/data/text.Char .Nat Block) +``` + +```clojure +(block start additional) +``` + +### block\_elements + +```clojure +Block +``` + +2580\-259F | block elements + +### bopomofo + +```clojure +Block +``` + +3100\-312F | bopomofo + +### bopomofo\_extended + +```clojure +Block +``` + +31A0\-31BF | bopomofo extended + +### box\_drawing + +```clojure +Block +``` + +2500\-257F | box drawing + +### braille\_patterns + +```clojure +Block +``` + +2800\-28FF | braille patterns + +### buhid + +```clojure +Block +``` + +1740\-175F | buhid + +### cherokee + +```clojure +Block +``` + +13A0\-13FF | cherokee + +### cjk\_compatibility + +```clojure +Block +``` + +3300\-33FF | cjk compatibility + +### cjk\_compatibility\_forms + +```clojure +Block +``` + +FE30\-FE4F | cjk compatibility forms + +### cjk\_compatibility\_ideographs + +```clojure +Block +``` + +F900\-FAFF | cjk compatibility ideographs + +### cjk\_radicals\_supplement + +```clojure +Block +``` + +2E80\-2EFF | cjk radicals supplement + +### cjk\_symbols\_and\_punctuation + +```clojure +Block +``` + +3000\-303F | cjk symbols and punctuation + +### cjk\_unified\_ideographs + +```clojure +Block +``` + +4E00\-9FFF | cjk unified ideographs + +### cjk\_unified\_ideographs\_extension\_a + +```clojure +Block +``` + +3400\-4DBF | cjk unified ideographs extension a + +### combining\_diacritical\_marks + +```clojure +Block +``` + +300\-36F | combining diacritical marks + +### combining\_diacritical\_marks\_for\_symbols + +```clojure +Block +``` + +20D0\-20FF | combining diacritical marks for symbols + +### combining\_half\_marks + +```clojure +Block +``` + +FE20\-FE2F | combining half marks + +### control\_pictures + +```clojure +Block +``` + +2400\-243F | control pictures + +### currency\_symbols + +```clojure +Block +``` + +20A0\-20CF | currency symbols + +### cyrillic + +```clojure +Block +``` + +400\-4FF | cyrillic + +### cyrillic\_supplementary + +```clojure +Block +``` + +500\-52F | cyrillic supplementary + +### devanagari + +```clojure +Block +``` + +900\-97F | devanagari + +### dingbats + +```clojure +Block +``` + +2700\-27BF | dingbats + +### enclosed\_alphanumerics + +```clojure +Block +``` + +2460\-24FF | enclosed alphanumerics + +### enclosed\_cjk\_letters\_and\_months + +```clojure +Block +``` + +3200\-32FF | enclosed cjk letters and months + +### end + +```clojure +(-> Block library/lux/data/text.Char) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Block) +``` + +### ethiopic + +```clojure +Block +``` + +1200\-137F | ethiopic + +### general\_punctuation + +```clojure +Block +``` + +2000\-206F | general punctuation + +### geometric\_shapes + +```clojure +Block +``` + +25A0\-25FF | geometric shapes + +### georgian + +```clojure +Block +``` + +10A0\-10FF | georgian + +### greek\_and\_coptic + +```clojure +Block +``` + +370\-3FF | greek and coptic + +### greek\_extended + +```clojure +Block +``` + +1F00\-1FFF | greek extended + +### gujarati + +```clojure +Block +``` + +A80\-AFF | gujarati + +### gurmukhi + +```clojure +Block +``` + +A00\-A7F | gurmukhi + +### halfwidth\_and\_fullwidth\_forms + +```clojure +Block +``` + +FF00\-FFEF | halfwidth and fullwidth forms + +### hangul\_compatibility\_jamo + +```clojure +Block +``` + +3130\-318F | hangul compatibility jamo + +### hangul\_jamo + +```clojure +Block +``` + +1100\-11FF | hangul jamo + +### hangul\_syllables + +```clojure +Block +``` + +AC00\-D7AF | hangul syllables + +### hanunoo + +```clojure +Block +``` + +1720\-173F | hanunoo + +### hash + +```clojure +(library/lux/abstract/hash.Hash Block) +``` + +### hebrew + +```clojure +Block +``` + +590\-5FF | hebrew + +### high\_private\_use\_surrogates + +```clojure +Block +``` + +DB80\-DBFF | high private use surrogates + +### high\_surrogates + +```clojure +Block +``` + +D800\-DB7F | high surrogates + +### hiragana + +```clojure +Block +``` + +3040\-309F | hiragana + +### ideographic\_description\_characters + +```clojure +Block +``` + +2FF0\-2FFF | ideographic description characters + +### ipa\_extensions + +```clojure +Block +``` + +250\-2AF | ipa extensions + +### kanbun + +```clojure +Block +``` + +3190\-319F | kanbun + +### kangxi\_radicals + +```clojure +Block +``` + +2F00\-2FDF | kangxi radicals + +### kannada + +```clojure +Block +``` + +C80\-CFF | kannada + +### katakana + +```clojure +Block +``` + +30A0\-30FF | katakana + +### katakana\_phonetic\_extensions + +```clojure +Block +``` + +31F0\-31FF | katakana phonetic extensions + +### khmer + +```clojure +Block +``` + +1780\-17FF | khmer + +### khmer\_symbols + +```clojure +Block +``` + +19E0\-19FF | khmer symbols + +### lao + +```clojure +Block +``` + +E80\-EFF | lao + +### latin\_1\_supplement + +```clojure +Block +``` + +A0\-FF | latin 1 supplement + +### latin\_extended\_a + +```clojure +Block +``` + +100\-17F | latin extended a + +### latin\_extended\_additional + +```clojure +Block +``` + +1E00\-1EFF | latin extended additional + +### latin\_extended\_b + +```clojure +Block +``` + +180\-24F | latin extended b + +### letterlike\_symbols + +```clojure +Block +``` + +2100\-214F | letterlike symbols + +### limbu + +```clojure +Block +``` + +1900\-194F | limbu + +### low\_surrogates + +```clojure +Block +``` + +DC00\-DFFF | low surrogates + +### malayalam + +```clojure +Block +``` + +D00\-D7F | malayalam + +### mathematical\_operators + +```clojure +Block +``` + +2200\-22FF | mathematical operators + +### miscellaneous\_mathematical\_symbols\_a + +```clojure +Block +``` + +27C0\-27EF | miscellaneous mathematical symbols a + +### miscellaneous\_mathematical\_symbols\_b + +```clojure +Block +``` + +2980\-29FF | miscellaneous mathematical symbols b + +### miscellaneous\_symbols + +```clojure +Block +``` + +2600\-26FF | miscellaneous symbols + +### miscellaneous\_symbols\_and\_arrows + +```clojure +Block +``` + +2B00\-2BFF | miscellaneous symbols and arrows + +### miscellaneous\_technical + +```clojure +Block +``` + +2300\-23FF | miscellaneous technical + +### mongolian + +```clojure +Block +``` + +1800\-18AF | mongolian + +### monoid + +```clojure +(library/lux/abstract/monoid.Monoid Block) +``` + +### myanmar + +```clojure +Block +``` + +1000\-109F | myanmar + +### number\_forms + +```clojure +Block +``` + +2150\-218F | number forms + +### ogham + +```clojure +Block +``` + +1680\-169F | ogham + +### optical\_character\_recognition + +```clojure +Block +``` + +2440\-245F | optical character recognition + +### oriya + +```clojure +Block +``` + +B00\-B7F | oriya + +### phonetic\_extensions + +```clojure +Block +``` + +1D00\-1D7F | phonetic extensions + +### private\_use\_area + +```clojure +Block +``` + +E000\-F8FF | private use area + +### runic + +```clojure +Block +``` + +16A0\-16FF | runic + +### sinhala + +```clojure +Block +``` + +D80\-DFF | sinhala + +### size + +```clojure +(-> Block .Nat) +``` + +### small\_form\_variants + +```clojure +Block +``` + +FE50\-FE6F | small form variants + +### spacing\_modifier\_letters + +```clojure +Block +``` + +2B0\-2FF | spacing modifier letters + +### specials + +```clojure +Block +``` + +FFF0\-FFFF | specials + +### start + +```clojure +(-> Block library/lux/data/text.Char) +``` + +### superscripts\_and\_subscripts + +```clojure +Block +``` + +2070\-209F | superscripts and subscripts + +### supplemental\_arrows\_a + +```clojure +Block +``` + +27F0\-27FF | supplemental arrows a + +### supplemental\_arrows\_b + +```clojure +Block +``` + +2900\-297F | supplemental arrows b + +### supplemental\_mathematical\_operators + +```clojure +Block +``` + +2A00\-2AFF | supplemental mathematical operators + +### syriac + +```clojure +Block +``` + +700\-74F | syriac + +### tagalog + +```clojure +Block +``` + +1700\-171F | tagalog + +### tagbanwa + +```clojure +Block +``` + +1760\-177F | tagbanwa + +### tai\_le + +```clojure +Block +``` + +1950\-197F | tai le + +### tamil + +```clojure +Block +``` + +B80\-BFF | tamil + +### telugu + +```clojure +Block +``` + +C00\-C7F | telugu + +### thaana + +```clojure +Block +``` + +780\-7BF | thaana + +### thai + +```clojure +Block +``` + +E00\-E7F | thai + +### tibetan + +```clojure +Block +``` + +F00\-FFF | tibetan + +### unified\_canadian\_aboriginal\_syllabics + +```clojure +Block +``` + +1400\-167F | unified canadian aboriginal syllabics + +### variation\_selectors + +```clojure +Block +``` + +FE00\-FE0F | variation selectors + +### within? + +```clojure +(All (_ a) (-> Block library/lux/data/text.Char .Bit)) +``` + +```clojure +(within? block char) +``` + +### yi\_radicals + +```clojure +Block +``` + +A490\-A4CF | yi radicals + +### yi\_syllables + +```clojure +Block +``` + +A000\-A48F | yi syllables + +### yijing\_hexagram\_symbols + +```clojure +Block +``` + +4DC0\-4DFF | yijing hexagram symbols + +___ + +# library/lux/data/text/unicode/set + +## Definitions + +### Set + +```clojure +... .Type +(primitive "library/lux/data/text/unicode/set.Set") +``` + +### ascii + +```clojure +Set +``` + +### ascii/alpha + +```clojure +Set +``` + +### ascii/alpha\_num + +```clojure +Set +``` + +### ascii/lower + +```clojure +Set +``` + +### ascii/numeric + +```clojure +Set +``` + +### ascii/upper + +```clojure +Set +``` + +### character + +```clojure +Set +``` + +### composite + +```clojure +(-> Set Set Set) +``` + +### end + +```clojure +(-> Set library/lux/data/text.Char) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Set) +``` + +### full + +```clojure +Set +``` + +### member? + +```clojure +(-> Set library/lux/data/text.Char .Bit) +``` + +```clojure +(member? set character) +``` + +### non\_character + +```clojure +Set +``` + +### set + +```clojure +(-> [library/lux/data/text/unicode/block.Block (.List library/lux/data/text/unicode/block.Block)] Set) +``` + +```clojure +(set [head tail]) +``` + +### start + +```clojure +(-> Set library/lux/data/text.Char) +``` + +___ + +# library/lux/debug + +## Definitions + +### :hole + +```clojure +.Macro +``` + +A typed 'hole'\. +Reveals the type expected of the expression that should go in the hole\. + +```clojure +(: (-> Nat Text) + (function (_ number) + (:hole))) + +... => + +.Text +``` + +### cannot\_represent\_value + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### here + +```clojure +.Macro +``` + +Shows the names and values of local bindings available around the call to 'here'\. + +```clojure +(let [foo 123 + bar +456 + baz +789.0] + (: Any + (here))) + +... => + +... foo: +123 + +... bar: +456 + +... baz: +789.0 + +[] + +................................................................ +................................................................ + +... Can optionally be given a list of definitions to focus on. + +... These definitions to focus on can include custom format to represent the values. + +(let [foo 123 + bar +456 + baz +789.0] + (: Any + (here {foo library/lux/data/text/format.nat}baz))) + +... => + +... foo: 123 + +... baz: +789.0 + +[] +``` + +### inspection + +```clojure +(library/lux/data/text/format.Format .Any) +``` + +A best\-effort attempt to generate a textual representation of a value, without knowing its type\. + +```clojure +(inspection value) +``` + +### log\! + +```clojure +(-> .Text .Any) +``` + +Prints/writes a message to standard output\. + +```clojure +(log! message) +``` + +### private + +```clojure +.Macro +``` + +Allows access to un\-exported definitions in other modules\. + +```clojure +... Module A + +(def: .private(secret_definition input) + (-> ??? ???) + (foo (bar (baz input)))) + +... Module B + +((private secret_definition) my_input) +``` + +### representation + +```clojure +(-> .Type .Any (library/lux/control/try.Try .Text)) +``` + +A best\-effort attempt to generate a textual representation of a value, while knowing its type\. + +```clojure +(representation type value) +``` + +### type\_hole + +```clojure +(library/lux/control/exception.Exception [.Location .Type]) +``` + +### unknown\_local\_binding + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +___ + +# library/lux/documentation + +## Definitions + +### Definition + +```clojure +... .Type +[.Text (library/lux/data/format/markdown.Markdown library/lux/data/format/markdown.Block)] +``` + +### Module + +```clojure +... .Type +[.Text .Text (library/lux/data/collection/set.Set .Text) (.List Definition)] +``` + +### default + +```clojure +.Macro +``` + +```clojure +(: Definition + (default documentation/lux/documentation.definition)) +``` + +### documentation + +```clojure +(-> (.List Module) .Text) +``` + +### documentation: + +```clojure +.Macro +``` + +```clojure +(documentation: default + "" + [(: Definition + (default documentation/lux/documentation.definition))]) +``` + +### module + +```clojure +.Macro +``` + +```clojure +(: (.ListModule) + (module _ + "" + [documentation/lux/documentation.default + documentation/lux/documentation.documentation: + documentation/lux/documentation.module + (default unqualified_identifier) + (default Definition) + (default Module) + (default documentation)] + [])) +``` + +### unqualified\_identifier + +```clojure +(library/lux/control/exception.Exception .Name) +``` + +___ + +# library/lux/extension + +## Definitions + +### analysis: + +```clojure +.Macro +``` + +Mechanism for defining extensions to Lux's analysis/type\-checking infrastructure\. + +```clojure +(analysis: ("my analysis" self phase archive [pass_through library/lux/control/parser/code.any]) + (phase archive pass_through)) +``` + +### directive: + +```clojure +.Macro +``` + +```clojure +(directive: ("my directive" self phase archive [parameters (library/lux/control/parser.somelibrary/lux/control/parser/code.any)]) + (do library/lux/tool/compiler/phase.monad + [.let[_ (library/lux/debug.log!(format "Successfully installed directive " (library/lux/data/text/format.textself) "!"))]] + (in library/lux/tool/compiler/language/lux/phase/directive.no_requirements))) +``` + +### generation: + +```clojure +.Macro +``` + +```clojure +(generation: ("my generation" self phase archive [pass_through <synthesis>.any]) + (for {library/lux/target.jvm + (\ library/lux/tool/compiler/phase.monadeach (|>> #library/lux/target/jvm.Embedded + library/lux/data/collection/row.row) + (phase archive pass_through))} + (phase archive pass_through))) +``` + +### synthesis: + +```clojure +.Macro +``` + +Mechanism for defining extensions to Lux's synthesis/optimization infrastructure\. + +```clojure +(synthesis: ("my synthesis" self phase archive [pass_through <analysis>.any]) + (phase archive pass_through)) +``` + +___ + +# library/lux/ffi + +## Definitions + +### \!\!\! + +```clojure +.Macro +``` + +Takes a \(Maybe ObjectType\) and returns a ObjectType\. +A \#\.None would get translated into a \(null\)\. + +```clojure +(= (null) + (!!! (??? (: java/lang/Thread (null))))) + +................................................................ +................................................................ + +(= "foo" + (!!! (??? "foo"))) +``` + +### :as + +```clojure +.Macro +``` + +```clojure +(:as java/lang/Object + (: java/lang/String + ???)) +``` + +### ??? + +```clojure +.Macro +``` + +Takes a \(potentially null\) ObjectType reference and creates a \(Maybe ObjectType\) for it\. + +```clojure +(= (??? (: java/lang/String (null))) + #library/lux.None) + +................................................................ +................................................................ + +(= (??? "YOLO") + (#library/lux.Some"YOLO")) +``` + +### Boolean + +```clojure +... .Type +(primitive "java.lang.Boolean") +``` + +The type of a \(boxed\) Boolean object\. + +### Byte + +```clojure +... .Type +(primitive "java.lang.Byte") +``` + +The type of a \(boxed\) Byte object\. + +### Character + +```clojure +... .Type +(primitive "java.lang.Character") +``` + +The type of a \(boxed\) Character object\. + +### Double + +```clojure +... .Type +(primitive "java.lang.Double") +``` + +The type of a \(boxed\) Double object\. + +### Float + +```clojure +... .Type +(primitive "java.lang.Float") +``` + +The type of a \(boxed\) Float object\. + +### Inheritance + +```clojure +... .Type +(Or .Any .Any .Any) +``` + +### Integer + +```clojure +... .Type +(primitive "java.lang.Integer") +``` + +The type of a \(boxed\) Integer object\. + +### Long + +```clojure +... .Type +(primitive "java.lang.Long") +``` + +The type of a \(boxed\) Long object\. + +### Privacy + +```clojure +... .Type +(Or .Any .Any .Any .Any) +``` + +### Short + +```clojure +... .Type +(primitive "java.lang.Short") +``` + +The type of a \(boxed\) Short object\. + +### State + +```clojure +... .Type +(Or .Any .Any .Any) +``` + +### array + +```clojure +.Macro +``` + +Create an array of the given type, with the given size\. + +```clojure +(array java/lang/Object 10) +``` + +### boolean + +```clojure +... .Type +(primitive "boolean") +``` + +The type of an \(unboxed\) boolean value\. + +### byte + +```clojure +... .Type +(primitive "byte") +``` + +The type of an \(unboxed\) byte value\. + +### byte\_to\_char + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Character ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +byte_to_char (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Byte foo))) +``` + +### byte\_to\_int + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Integer ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +byte_to_int (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Byte foo))) +``` + +### byte\_to\_long + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + Long ( + +byte_to_long (: + + Byte foo))) +``` + +### cannot\_cast\_to\_non\_object + +```clojure +(library/lux/control/exception.Exception (library/lux/target/jvm/type.Type library/lux/target/jvm/type/category.Value)) +``` + +### cannot\_convert\_to\_jvm\_type + +```clojure +(library/lux/control/exception.Exception .Type) +``` + +### char + +```clojure +... .Type +(primitive "char") +``` + +The type of an \(unboxed\) char value\. + +### char\_to\_byte + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + Byte ( + + + + + + + + + + + + + + + + + + + + + + + + + + +char_to_byte (: + + + + + + + + + + + + + + + + + + + + + + + + + + + Character foo))) +``` + +### char\_to\_int + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Integer ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + +char_to_int (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Character foo))) +``` + +### char\_to\_long + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Long ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +char_to_long (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Character foo))) +``` + +### char\_to\_short + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Short ( + + + + + + + + + + + + + + + + + + + + + + + + + + + +char_to_short (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + Character foo))) +``` + +### check + +```clojure +.Macro +``` + +Checks whether an object is an instance of a particular class\. +Caveat emptor: Cannot check for polymorphism, so avoid using parameterized classes\. + +```clojure +(case (check String "YOLO") + (#library/lux.Somevalue_as_string) + #library/lux.None) +``` + +### class: + +```clojure +.Macro +``` + +Allows defining JVM classes in Lux code\. + +```clojure +(class: #final (TestClass A) [Runnable] + + (#private foo boolean) + (#private bar A) + (#private baz java/lang/Object) + + (#public [] (new [value A]) [] + (exec + (:= ::foo #1) + (:= ::bar value) + (:= ::baz "") + [])) + (#public (virtual) java/lang/Object + "") + (#public #static (static) java/lang/Object + "") + (Runnable [] (run) void + [])) + +... The tuple corresponds to parent interfaces. + +... An optional super-class can be specified before the tuple. If not specified, java.lang.Object will be assumed. + +... Fields and methods defined in the class can be used with special syntax. + +... For example: + +... ::resolved, for accessing the 'resolved' field. + +... (:= ::resolved #1) for modifying it. + +... (::new! []) for calling the class's constructor. + +... (::resolve! container [value]) for calling the 'resolve' method. +``` + +### class\_for + +```clojure +.Macro +``` + +Loads the class as a java\.lang\.Class object\. + +```clojure +(class_for java/lang/String) +``` + +### class\_name\_cannot\_be\_a\_type\_variable + +```clojure +(library/lux/control/exception.Exception [.Text (.List (library/lux/target/jvm/type.Type library/lux/target/jvm/type/category.Var))]) +``` + +### class\_names\_cannot\_contain\_periods + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### do\_to + +```clojure +.Macro +``` + +Call a variety of methods on an object\. Then, return the object\. + +```clojure +(do_to object + (ClassName::method1 arg0 arg1 arg2) + (ClassName::method2 arg3 arg4 arg5)) +``` + +### double + +```clojure +... .Type +(primitive "double") +``` + +The type of an \(unboxed\) double value\. + +### double\_to\_float + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + Float ( + + + + + + + +double_to_float (: + + + + + + + + Double foo))) +``` + +### double\_to\_int + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + Integer ( + + + + + +double_to_int (: + + + + + + Double foo))) +``` + +### double\_to\_long + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + Long ( + + + + + + +double_to_long (: + + + + + + + Double foo))) +``` + +### float + +```clojure +... .Type +(primitive "float") +``` + +The type of an \(unboxed\) float value\. + +### float\_to\_double + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + Double ( + + + + + + + + + + + +float_to_double (: + + + + + + + + + + + + Float foo))) +``` + +### float\_to\_int + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + Integer ( + + + + + + + + + +float_to_int (: + + + + + + + + + + Float foo))) +``` + +### float\_to\_long + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + Long ( + + + + + + + + + + +float_to_long (: + + + + + + + + + + + Float foo))) +``` + +### import: + +```clojure +.Macro +``` + +Allows importing JVM classes, and using them as types\. + +```clojure +... Their methods, fields and enum options can also be imported. + +(import: java/lang/Object + ["#::." + (new []) + (equals [java/lang/Object] boolean) + (wait [int] #io #try void)]) + +................................................................ +................................................................ + +... Special options can also be given for the return values. + +... #? means that the values will be returned inside a Maybe type. That way, null becomes #.None. + +... #try means that the computation might throw an exception, and the return value will be wrapped by the Try type. + +... #io means the computation has side effects, and will be wrapped by the IO type. + +... These options must show up in the following order [#io #try #?] (although, each option can be used independently). + +(import: java/lang/String + ["#::." + (new [[byte]]) + (#static valueOf [char] java/lang/String) + (#static valueOf #as int_valueOf [int] java/lang/String)]) + +(import: (java/util/List e) + ["#::." + (size [] int) + (get [int] e)]) + +(import: (java/util/ArrayList a) + ["#::." + ([T] toArray [[T]] [T])]) + +................................................................ +................................................................ + +... The class-type that is generated is of the fully-qualified name. + +... This avoids a clash between the java.util.List type, and Lux's own List type. + +... All enum options to be imported must be specified. + +(import: java/lang/Character$UnicodeScript + ["#::." + (#enum ARABIC CYRILLIC LATIN)]) + +................................................................ +................................................................ + +... It should also be noted, the only types that may show up in method arguments or return values may be Java classes, arrays, primitives, void or type-vars. + +... Lux types, such as Maybe cannot be named (otherwise, they'd be confused for Java classes). + +(import: (lux/concurrency/async/JvmAsync A) + ["#::." + (resolve [A] boolean) + (poll [] A) + (wasResolved [] boolean) + (waitOn [lux/Function] void) + (#static [A] make [A] (lux/concurrency/async/JvmAsync A))]) + +................................................................ +................................................................ + +... Also, the names of the imported members will look like Class::member + +(java/lang/Object::new []) + +(java/lang/Object::equals [other_object] my_object) + +(java/util/List::size [] my_list) + +java/lang/Character$UnicodeScript::LATIN +``` + +### int + +```clojure +... .Type +(primitive "int") +``` + +The type of an \(unboxed\) int value\. + +### int\_to\_byte + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + Byte ( + + + + + + + + + + + + + +int_to_byte (: + + + + + + + + + + + + + + Integer foo))) +``` + +### int\_to\_char + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + Character ( + + + + + + + + + + + + + + + + + + +int_to_char (: + + + + + + + + + + + + + + + + + + + Integer foo))) +``` + +### int\_to\_double + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + Double ( + + + + + + + + + + + + + + + + + +int_to_double (: + + + + + + + + + + + + + + + + + + Integer foo))) +``` + +### int\_to\_float + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + Float ( + + + + + + + + + + + + + + + + +int_to_float (: + + + + + + + + + + + + + + + + + Integer foo))) +``` + +### int\_to\_long + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + Long ( + + + + + + + + + + + + + + + +int_to_long (: + + + + + + + + + + + + + + + + Integer foo))) +``` + +### int\_to\_short + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + Short ( + + + + + + + + + + + + + + +int_to_short (: + + + + + + + + + + + + + + + Integer foo))) +``` + +### interface: + +```clojure +.Macro +``` + +Allows defining JVM interfaces\. + +```clojure +(interface: TestInterface + ([] foo [boolean String] void #throws [Exception])) +``` + +### length + +```clojure +.Macro +``` + +Gives the length of an array\. + +```clojure +(length my_array) +``` + +### long + +```clojure +... .Type +(primitive "long") +``` + +The type of an \(unboxed\) long value\. + +### long\_to\_byte + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + Byte ( + + + + + + + + + + + + + + + + + + + + +long_to_byte (: + + + + + + + + + + + + + + + + + + + + + Long foo))) +``` + +### long\_to\_char + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Character ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +long_to_char (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Long foo))) +``` + +### long\_to\_double + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + Double ( + + + + + + + + + + + + + + + + + + + + + + + + +long_to_double (: + + + + + + + + + + + + + + + + + + + + + + + + + Long foo))) +``` + +### long\_to\_float + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + Float ( + + + + + + + + + + + + + + + + + + + + + + + +long_to_float (: + + + + + + + + + + + + + + + + + + + + + + + + Long foo))) +``` + +### long\_to\_int + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + Integer ( + + + + + + + + + + + + + + + + + + + + + + +long_to_int (: + + + + + + + + + + + + + + + + + + + + + + + Long foo))) +``` + +### long\_to\_short + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + Short ( + + + + + + + + + + + + + + + + + + + + + +long_to_short (: + + + + + + + + + + + + + + + + + + + + + + Long foo))) +``` + +### null + +```clojure +.Macro +``` + +The null pointer\. + +```clojure +(null) +``` + +### null? + +```clojure +(-> (primitive "java.lang.Object") .Bit) +``` + +Test for the null pointer\. + +```clojure +(= true + (null? (null))) + +................................................................ +................................................................ + +(= false + (null? "YOLO")) +``` + +### object + +```clojure +.Macro +``` + +Allows defining anonymous classes\. + +```clojure +... The 1st tuple corresponds to class-level type-variables. + +... The 2nd tuple corresponds to parent interfaces. + +... The 3rd tuple corresponds to arguments to the super class constructor. + +... An optional super-class can be specified before the 1st tuple. If not specified, java.lang.Object will be assumed. + +(object [] [Runnable] + [] + (Runnable [] (run self) void + (exec + (do_something some_value) + []))) +``` + +### read\! + +```clojure +.Macro +``` + +Loads an element from an array\. + +```clojure +(read! 10 my_array) +``` + +### short + +```clojure +... .Type +(primitive "short") +``` + +The type of an \(unboxed\) short value\. + +### short\_to\_char + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Character ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +short_to_char (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Short foo))) +``` + +### short\_to\_int + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Integer ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +short_to_int (: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Short foo))) +``` + +### short\_to\_long + +```clojure +.Macro +``` + +Type converter\. + +```clojure + (: + + + + + Long ( + + + +short_to_long (: + + + + Short foo))) +``` + +### synchronized + +```clojure +.Macro +``` + +Evaluates body, while holding a lock on a given object\. + +```clojure +(synchronized object_to_be_locked + (exec + (do something) + (dosomething else) + (finish the computation))) +``` + +### type + +```clojure +.Macro +``` + +```clojure +(: Type + (type java/lang/String)) +``` + +### unexpected\_type\_variable + +```clojure +(library/lux/control/exception.Exception [.Text (.List (library/lux/target/jvm/type.Type library/lux/target/jvm/type/category.Var))]) +``` + +### write\! + +```clojure +.Macro +``` + +Stores an element into an array\. + +```clojure +(write! 10 my_object my_array) +``` + +___ + +# library/lux/locale + +## Definitions + +### Locale + +```clojure +... .Type +(primitive "library/lux/locale.Locale") +``` + +A description of a locale; with territory, \(optional\) language, and \(optional\) text\-encoding\. + +### code + +```clojure +(-> Locale .Text) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Locale) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash Locale) +``` + +### locale + +```clojure +(-> library/lux/locale/language.Language (.Maybe library/lux/locale/territory.Territory) (.Maybe library/lux/data/text/encoding.Encoding) Locale) +``` + +```clojure +(locale language territory encoding) +``` + +___ + +# library/lux/locale/language + +## Definitions + +### Language + +```clojure +... .Type +(primitive "library/lux/locale/language.Language") +``` + +An ISO 639 language\. + +### abkhazian + +```clojure +Language +``` + +### achinese + +```clojure +Language +``` + +### acoli + +```clojure +Language +``` + +### adangme + +```clojure +Language +``` + +### adyghe + +```clojure +Language +``` + +### afar + +```clojure +Language +``` + +### afrihili + +```clojure +Language +``` + +### afrikaans + +```clojure +Language +``` + +### afro\_asiatic + +```clojure +Language +``` + +### ainu + +```clojure +Language +``` + +### akan + +```clojure +Language +``` + +### akkadian + +```clojure +Language +``` + +### albanian + +```clojure +Language +``` + +### alemannic + +```clojure +Language +``` + +### aleut + +```clojure +Language +``` + +### algonquian + +```clojure +Language +``` + +### alsatian + +```clojure +Language +``` + +### altaic + +```clojure +Language +``` + +### amharic + +```clojure +Language +``` + +### ancient\_greek + +```clojure +Language +``` + +### angika + +```clojure +Language +``` + +### apache + +```clojure +Language +``` + +### arabic + +```clojure +Language +``` + +### aragonese + +```clojure +Language +``` + +### arapaho + +```clojure +Language +``` + +### arawak + +```clojure +Language +``` + +### armenian + +```clojure +Language +``` + +### aromanian + +```clojure +Language +``` + +### artificial + +```clojure +Language +``` + +### arumanian + +```clojure +Language +``` + +### assamese + +```clojure +Language +``` + +### asturian + +```clojure +Language +``` + +### asturleonese + +```clojure +Language +``` + +### athapascan + +```clojure +Language +``` + +### australian + +```clojure +Language +``` + +### austronesian + +```clojure +Language +``` + +### avaric + +```clojure +Language +``` + +### avestan + +```clojure +Language +``` + +### awadhi + +```clojure +Language +``` + +### aymara + +```clojure +Language +``` + +### azerbaijani + +```clojure +Language +``` + +### bable + +```clojure +Language +``` + +### balinese + +```clojure +Language +``` + +### baltic + +```clojure +Language +``` + +### baluchi + +```clojure +Language +``` + +### bambara + +```clojure +Language +``` + +### bamileke + +```clojure +Language +``` + +### banda + +```clojure +Language +``` + +### bantu + +```clojure +Language +``` + +### basa + +```clojure +Language +``` + +### bashkir + +```clojure +Language +``` + +### basque + +```clojure +Language +``` + +### batak + +```clojure +Language +``` + +### beja + +```clojure +Language +``` + +### belarusian + +```clojure +Language +``` + +### bemba + +```clojure +Language +``` + +### bengali + +```clojure +Language +``` + +### berber + +```clojure +Language +``` + +### bhojpuri + +```clojure +Language +``` + +### bihari + +```clojure +Language +``` + +### bikol + +```clojure +Language +``` + +### bilin + +```clojure +Language +``` + +### bini + +```clojure +Language +``` + +### bislama + +```clojure +Language +``` + +### blin + +```clojure +Language +``` + +### blissymbols + +```clojure +Language +``` + +### bokmal + +```clojure +Language +``` + +### bosnian + +```clojure +Language +``` + +### braj + +```clojure +Language +``` + +### breton + +```clojure +Language +``` + +### buginese + +```clojure +Language +``` + +### bulgarian + +```clojure +Language +``` + +### buriat + +```clojure +Language +``` + +### burmese + +```clojure +Language +``` + +### caddo + +```clojure +Language +``` + +### castilian + +```clojure +Language +``` + +### catalan + +```clojure +Language +``` + +### caucasian + +```clojure +Language +``` + +### cebuano + +```clojure +Language +``` + +### celtic + +```clojure +Language +``` + +### central\_american\_indian + +```clojure +Language +``` + +### central\_khmer + +```clojure +Language +``` + +### chagatai + +```clojure +Language +``` + +### chamic + +```clojure +Language +``` + +### chamorro + +```clojure +Language +``` + +### chechen + +```clojure +Language +``` + +### cherokee + +```clojure +Language +``` + +### chewa + +```clojure +Language +``` + +### cheyenne + +```clojure +Language +``` + +### chibcha + +```clojure +Language +``` + +### chichewa + +```clojure +Language +``` + +### chinese + +```clojure +Language +``` + +### chinook + +```clojure +Language +``` + +### chipewyan + +```clojure +Language +``` + +### choctaw + +```clojure +Language +``` + +### church\_slavic + +```clojure +Language +``` + +### church\_slavonic + +```clojure +Language +``` + +### chuukese + +```clojure +Language +``` + +### chuvash + +```clojure +Language +``` + +### classical\_nepal\_bhasa + +```clojure +Language +``` + +### classical\_newari + +```clojure +Language +``` + +### classical\_syriac + +```clojure +Language +``` + +### code + +```clojure +(-> Language .Text) +``` + +### cook\_islands\_maori + +```clojure +Language +``` + +### coptic + +```clojure +Language +``` + +### cornish + +```clojure +Language +``` + +### corsican + +```clojure +Language +``` + +### cree + +```clojure +Language +``` + +### creek + +```clojure +Language +``` + +### creoles\_and\_pidgins + +```clojure +Language +``` + +### creoles\_and\_pidgins/english + +```clojure +Language +``` + +### creoles\_and\_pidgins/french + +```clojure +Language +``` + +### creoles\_and\_pidgins/portuguese + +```clojure +Language +``` + +### crimean + +```clojure +Language +``` + +### croatian + +```clojure +Language +``` + +### cushitic + +```clojure +Language +``` + +### czech + +```clojure +Language +``` + +### dakota + +```clojure +Language +``` + +### danish + +```clojure +Language +``` + +### dargwa + +```clojure +Language +``` + +### delaware + +```clojure +Language +``` + +### dhivehi + +```clojure +Language +``` + +### dimili + +```clojure +Language +``` + +### dimli + +```clojure +Language +``` + +### dinka + +```clojure +Language +``` + +### dogri + +```clojure +Language +``` + +### dogrib + +```clojure +Language +``` + +### dravidian + +```clojure +Language +``` + +### duala + +```clojure +Language +``` + +### dutch + +```clojure +Language +``` + +### dyula + +```clojure +Language +``` + +### dzongkha + +```clojure +Language +``` + +### eastern\_frisian + +```clojure +Language +``` + +### edo + +```clojure +Language +``` + +### efik + +```clojure +Language +``` + +### egyptian + +```clojure +Language +``` + +### ekajuk + +```clojure +Language +``` + +### elamite + +```clojure +Language +``` + +### english + +```clojure +Language +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Language) +``` + +### erzya + +```clojure +Language +``` + +### esperanto + +```clojure +Language +``` + +### estonian + +```clojure +Language +``` + +### ewe + +```clojure +Language +``` + +### ewondo + +```clojure +Language +``` + +### fang + +```clojure +Language +``` + +### fanti + +```clojure +Language +``` + +### faroese + +```clojure +Language +``` + +### fijian + +```clojure +Language +``` + +### filipino + +```clojure +Language +``` + +### finnish + +```clojure +Language +``` + +### finno\_ugrian + +```clojure +Language +``` + +### flemish + +```clojure +Language +``` + +### fon + +```clojure +Language +``` + +### french + +```clojure +Language +``` + +### friulian + +```clojure +Language +``` + +### fulah + +```clojure +Language +``` + +### ga + +```clojure +Language +``` + +### gaelic + +```clojure +Language +``` + +### galibi\_carib + +```clojure +Language +``` + +### galician + +```clojure +Language +``` + +### ganda + +```clojure +Language +``` + +### gayo + +```clojure +Language +``` + +### gbaya + +```clojure +Language +``` + +### geez + +```clojure +Language +``` + +### georgian + +```clojure +Language +``` + +### german + +```clojure +Language +``` + +### germanic + +```clojure +Language +``` + +### gikuyu + +```clojure +Language +``` + +### gilbertese + +```clojure +Language +``` + +### gondi + +```clojure +Language +``` + +### gorontalo + +```clojure +Language +``` + +### gothic + +```clojure +Language +``` + +### grebo + +```clojure +Language +``` + +### greek + +```clojure +Language +``` + +### greenlandic + +```clojure +Language +``` + +### guarani + +```clojure +Language +``` + +### gujarati + +```clojure +Language +``` + +### gwich'in + +```clojure +Language +``` + +### haida + +```clojure +Language +``` + +### haitian + +```clojure +Language +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash Language) +``` + +### hausa + +```clojure +Language +``` + +### hawaiian + +```clojure +Language +``` + +### hebrew + +```clojure +Language +``` + +### herero + +```clojure +Language +``` + +### hiligaynon + +```clojure +Language +``` + +### himachali + +```clojure +Language +``` + +### hindi + +```clojure +Language +``` + +### hiri\_motu + +```clojure +Language +``` + +### hittite + +```clojure +Language +``` + +### hmong + +```clojure +Language +``` + +### hungarian + +```clojure +Language +``` + +### hupa + +```clojure +Language +``` + +### iban + +```clojure +Language +``` + +### icelandic + +```clojure +Language +``` + +### ido + +```clojure +Language +``` + +### igbo + +```clojure +Language +``` + +### ijo + +```clojure +Language +``` + +### iloko + +```clojure +Language +``` + +### imperial\_aramaic + +```clojure +Language +``` + +### inari + +```clojure +Language +``` + +### indic + +```clojure +Language +``` + +### indo\_european + +```clojure +Language +``` + +### indonesian + +```clojure +Language +``` + +### ingush + +```clojure +Language +``` + +### interlingua + +```clojure +Language +``` + +### interlingue + +```clojure +Language +``` + +### inuktitut + +```clojure +Language +``` + +### inupiaq + +```clojure +Language +``` + +### iranian + +```clojure +Language +``` + +### irish + +```clojure +Language +``` + +### iroquoian + +```clojure +Language +``` + +### italian + +```clojure +Language +``` + +### japanese + +```clojure +Language +``` + +### javanese + +```clojure +Language +``` + +### jingpho + +```clojure +Language +``` + +### judeo\_arabic + +```clojure +Language +``` + +### judeo\_persian + +```clojure +Language +``` + +### kabardian + +```clojure +Language +``` + +### kabyle + +```clojure +Language +``` + +### kachin + +```clojure +Language +``` + +### kalaallisut + +```clojure +Language +``` + +### kalmyk + +```clojure +Language +``` + +### kamba + +```clojure +Language +``` + +### kannada + +```clojure +Language +``` + +### kanuri + +```clojure +Language +``` + +### kapampangan + +```clojure +Language +``` + +### kara\_kalpak + +```clojure +Language +``` + +### karachay\_balkar + +```clojure +Language +``` + +### karelian + +```clojure +Language +``` + +### karen + +```clojure +Language +``` + +### kashmiri + +```clojure +Language +``` + +### kashubian + +```clojure +Language +``` + +### kawi + +```clojure +Language +``` + +### kazakh + +```clojure +Language +``` + +### khasi + +```clojure +Language +``` + +### khoisan + +```clojure +Language +``` + +### khotanese + +```clojure +Language +``` + +### kimbundu + +```clojure +Language +``` + +### kinyarwanda + +```clojure +Language +``` + +### kirdki + +```clojure +Language +``` + +### kirmanjki + +```clojure +Language +``` + +### klingon + +```clojure +Language +``` + +### komi + +```clojure +Language +``` + +### kongo + +```clojure +Language +``` + +### konkani + +```clojure +Language +``` + +### korean + +```clojure +Language +``` + +### kosraean + +```clojure +Language +``` + +### kpelle + +```clojure +Language +``` + +### kru + +```clojure +Language +``` + +### kumyk + +```clojure +Language +``` + +### kurdish + +```clojure +Language +``` + +### kurukh + +```clojure +Language +``` + +### kutenai + +```clojure +Language +``` + +### kwanyama + +```clojure +Language +``` + +### kyrgyz + +```clojure +Language +``` + +### ladino + +```clojure +Language +``` + +### lahnda + +```clojure +Language +``` + +### lamba + +```clojure +Language +``` + +### land\_dayak + +```clojure +Language +``` + +### lao + +```clojure +Language +``` + +### latin + +```clojure +Language +``` + +### latvian + +```clojure +Language +``` + +### leonese + +```clojure +Language +``` + +### lezghian + +```clojure +Language +``` + +### limburgan + +```clojure +Language +``` + +### lingala + +```clojure +Language +``` + +### lithuanian + +```clojure +Language +``` + +### lojban + +```clojure +Language +``` + +### low\_german + +```clojure +Language +``` + +### lower\_sorbian + +```clojure +Language +``` + +### lozi + +```clojure +Language +``` + +### luba\_katanga + +```clojure +Language +``` + +### luba\_lulua + +```clojure +Language +``` + +### luiseno + +```clojure +Language +``` + +### lule + +```clojure +Language +``` + +### lunda + +```clojure +Language +``` + +### luo + +```clojure +Language +``` + +### lushai + +```clojure +Language +``` + +### luxembourgish + +```clojure +Language +``` + +### macedo\_romanian + +```clojure +Language +``` + +### macedonian + +```clojure +Language +``` + +### madurese + +```clojure +Language +``` + +### magahi + +```clojure +Language +``` + +### maithili + +```clojure +Language +``` + +### makasar + +```clojure +Language +``` + +### malagasy + +```clojure +Language +``` + +### malay + +```clojure +Language +``` + +### malayalam + +```clojure +Language +``` + +### maldivian + +```clojure +Language +``` + +### maltese + +```clojure +Language +``` + +### manchu + +```clojure +Language +``` + +### mandar + +```clojure +Language +``` + +### mandingo + +```clojure +Language +``` + +### manipuri + +```clojure +Language +``` + +### manobo + +```clojure +Language +``` + +### manx + +```clojure +Language +``` + +### maori + +```clojure +Language +``` + +### mapudungun + +```clojure +Language +``` + +### marathi + +```clojure +Language +``` + +### mari + +```clojure +Language +``` + +### marshallese + +```clojure +Language +``` + +### marwari + +```clojure +Language +``` + +### masai + +```clojure +Language +``` + +### mayan + +```clojure +Language +``` + +### mende + +```clojure +Language +``` + +### mi'kmaq + +```clojure +Language +``` + +### micmac + +```clojure +Language +``` + +### middle\_dutch + +```clojure +Language +``` + +### middle\_english + +```clojure +Language +``` + +### middle\_french + +```clojure +Language +``` + +### middle\_high\_german + +```clojure +Language +``` + +### middle\_irish + +```clojure +Language +``` + +### minangkabau + +```clojure +Language +``` + +### mirandese + +```clojure +Language +``` + +### mohawk + +```clojure +Language +``` + +### moksha + +```clojure +Language +``` + +### moldavian + +```clojure +Language +``` + +### moldovan + +```clojure +Language +``` + +### mon\_khmer + +```clojure +Language +``` + +### mongo + +```clojure +Language +``` + +### mongolian + +```clojure +Language +``` + +### montenegrin + +```clojure +Language +``` + +### mossi + +```clojure +Language +``` + +### multiple + +```clojure +Language +``` + +### munda + +```clojure +Language +``` + +### n'ko + +```clojure +Language +``` + +### nahuatl + +```clojure +Language +``` + +### name + +```clojure +(-> Language .Text) +``` + +### nauru + +```clojure +Language +``` + +### navajo + +```clojure +Language +``` + +### ndonga + +```clojure +Language +``` + +### neapolitan + +```clojure +Language +``` + +### nepal\_bhasa + +```clojure +Language +``` + +### nepali + +```clojure +Language +``` + +### newari + +```clojure +Language +``` + +### nias + +```clojure +Language +``` + +### niger\_kordofanian + +```clojure +Language +``` + +### nilo\_saharan + +```clojure +Language +``` + +### niuean + +```clojure +Language +``` + +### nogai + +```clojure +Language +``` + +### north\_american\_indian + +```clojure +Language +``` + +### north\_ndebele + +```clojure +Language +``` + +### northern\_frisian + +```clojure +Language +``` + +### northern\_sami + +```clojure +Language +``` + +### northern\_sotho + +```clojure +Language +``` + +### norwegian + +```clojure +Language +``` + +### not\_applicable + +```clojure +Language +``` + +### nubian + +```clojure +Language +``` + +### nuosu + +```clojure +Language +``` + +### nyamwezi + +```clojure +Language +``` + +### nyanja + +```clojure +Language +``` + +### nyankole + +```clojure +Language +``` + +### nynorsk + +```clojure +Language +``` + +### nyoro + +```clojure +Language +``` + +### nzima + +```clojure +Language +``` + +### occitan + +```clojure +Language +``` + +### official\_aramaic + +```clojure +Language +``` + +### oirat + +```clojure +Language +``` + +### ojibwa + +```clojure +Language +``` + +### old\_bulgarian + +```clojure +Language +``` + +### old\_church\_slavonic + +```clojure +Language +``` + +### old\_english + +```clojure +Language +``` + +### old\_french + +```clojure +Language +``` + +### old\_high\_german + +```clojure +Language +``` + +### old\_irish + +```clojure +Language +``` + +### old\_newari + +```clojure +Language +``` + +### old\_norse + +```clojure +Language +``` + +### old\_persian + +```clojure +Language +``` + +### old\_provencal + +```clojure +Language +``` + +### old\_slavonic + +```clojure +Language +``` + +### oriya + +```clojure +Language +``` + +### oromo + +```clojure +Language +``` + +### osage + +```clojure +Language +``` + +### ossetic + +```clojure +Language +``` + +### otomian + +```clojure +Language +``` + +### ottoman\_turkish + +```clojure +Language +``` + +### pahlavi + +```clojure +Language +``` + +### palauan + +```clojure +Language +``` + +### pali + +```clojure +Language +``` + +### pampanga + +```clojure +Language +``` + +### pangasinan + +```clojure +Language +``` + +### papiamento + +```clojure +Language +``` + +### papuan + +```clojure +Language +``` + +### pashto + +```clojure +Language +``` + +### pedi + +```clojure +Language +``` + +### persian + +```clojure +Language +``` + +### philippine + +```clojure +Language +``` + +### phoenician + +```clojure +Language +``` + +### pohnpeian + +```clojure +Language +``` + +### polish + +```clojure +Language +``` + +### portuguese + +```clojure +Language +``` + +### prakrit + +```clojure +Language +``` + +### provencal + +```clojure +Language +``` + +### punjabi + +```clojure +Language +``` + +### quechua + +```clojure +Language +``` + +### rajasthani + +```clojure +Language +``` + +### rapanui + +```clojure +Language +``` + +### rarotongan + +```clojure +Language +``` + +### romance + +```clojure +Language +``` + +### romanian + +```clojure +Language +``` + +### romansh + +```clojure +Language +``` + +### romany + +```clojure +Language +``` + +### rundi + +```clojure +Language +``` + +### russian + +```clojure +Language +``` + +### sakan + +```clojure +Language +``` + +### salishan + +```clojure +Language +``` + +### samaritan\_aramaic + +```clojure +Language +``` + +### sami + +```clojure +Language +``` + +### samoan + +```clojure +Language +``` + +### sandawe + +```clojure +Language +``` + +### sango + +```clojure +Language +``` + +### sanskrit + +```clojure +Language +``` + +### santali + +```clojure +Language +``` + +### sardinian + +```clojure +Language +``` + +### sasak + +```clojure +Language +``` + +### scots + +```clojure +Language +``` + +### selkup + +```clojure +Language +``` + +### semitic + +```clojure +Language +``` + +### sepedi + +```clojure +Language +``` + +### serbian + +```clojure +Language +``` + +### serer + +```clojure +Language +``` + +### shan + +```clojure +Language +``` + +### shona + +```clojure +Language +``` + +### sichuan\_yi + +```clojure +Language +``` + +### sicilian + +```clojure +Language +``` + +### sidamo + +```clojure +Language +``` + +### sign + +```clojure +Language +``` + +### siksika + +```clojure +Language +``` + +### sindhi + +```clojure +Language +``` + +### sinhalese + +```clojure +Language +``` + +### sino\_tibetan + +```clojure +Language +``` + +### siouan + +```clojure +Language +``` + +### skolt\_sami + +```clojure +Language +``` + +### slavey + +```clojure +Language +``` + +### slavic + +```clojure +Language +``` + +### slovak + +```clojure +Language +``` + +### slovenian + +```clojure +Language +``` + +### sogdian + +```clojure +Language +``` + +### somali + +```clojure +Language +``` + +### songhai + +```clojure +Language +``` + +### soninke + +```clojure +Language +``` + +### sorbian + +```clojure +Language +``` + +### south\_american\_indian + +```clojure +Language +``` + +### south\_ndebele + +```clojure +Language +``` + +### southern\_altai + +```clojure +Language +``` + +### southern\_sami + +```clojure +Language +``` + +### southern\_sotho + +```clojure +Language +``` + +### spanish + +```clojure +Language +``` + +### sranan\_tongo + +```clojure +Language +``` + +### standard\_moroccan\_tamazight + +```clojure +Language +``` + +### sukuma + +```clojure +Language +``` + +### sumerian + +```clojure +Language +``` + +### sundanese + +```clojure +Language +``` + +### susu + +```clojure +Language +``` + +### swahili + +```clojure +Language +``` + +### swati + +```clojure +Language +``` + +### swedish + +```clojure +Language +``` + +### swiss\_german + +```clojure +Language +``` + +### syriac + +```clojure +Language +``` + +### tagalog + +```clojure +Language +``` + +### tahitian + +```clojure +Language +``` + +### tai + +```clojure +Language +``` + +### tajik + +```clojure +Language +``` + +### tamashek + +```clojure +Language +``` + +### tamil + +```clojure +Language +``` + +### tatar + +```clojure +Language +``` + +### telugu + +```clojure +Language +``` + +### tereno + +```clojure +Language +``` + +### tetum + +```clojure +Language +``` + +### thai + +```clojure +Language +``` + +### tibetan + +```clojure +Language +``` + +### tigre + +```clojure +Language +``` + +### tigrinya + +```clojure +Language +``` + +### timne + +```clojure +Language +``` + +### tiv + +```clojure +Language +``` + +### tlingit + +```clojure +Language +``` + +### tok\_pisin + +```clojure +Language +``` + +### tokelau + +```clojure +Language +``` + +### tonga + +```clojure +Language +``` + +### tongan + +```clojure +Language +``` + +### tsimshian + +```clojure +Language +``` + +### tsonga + +```clojure +Language +``` + +### tswana + +```clojure +Language +``` + +### tumbuka + +```clojure +Language +``` + +### tupi + +```clojure +Language +``` + +### turkish + +```clojure +Language +``` + +### turkmen + +```clojure +Language +``` + +### tuvalu + +```clojure +Language +``` + +### tuvinian + +```clojure +Language +``` + +### twi + +```clojure +Language +``` + +### udmurt + +```clojure +Language +``` + +### ugaritic + +```clojure +Language +``` + +### ukrainian + +```clojure +Language +``` + +### umbundu + +```clojure +Language +``` + +### uncoded + +```clojure +Language +``` + +### undetermined + +```clojure +Language +``` + +### upper\_sorbian + +```clojure +Language +``` + +### urdu + +```clojure +Language +``` + +### uyghur + +```clojure +Language +``` + +### uzbek + +```clojure +Language +``` + +### vai + +```clojure +Language +``` + +### valencian + +```clojure +Language +``` + +### venda + +```clojure +Language +``` + +### vietnamese + +```clojure +Language +``` + +### volapük + +```clojure +Language +``` + +### votic + +```clojure +Language +``` + +### wakashan + +```clojure +Language +``` + +### walamo + +```clojure +Language +``` + +### walloon + +```clojure +Language +``` + +### waray + +```clojure +Language +``` + +### washo + +```clojure +Language +``` + +### welsh + +```clojure +Language +``` + +### western\_frisian + +```clojure +Language +``` + +### wolof + +```clojure +Language +``` + +### xhosa + +```clojure +Language +``` + +### yakut + +```clojure +Language +``` + +### yao + +```clojure +Language +``` + +### yapese + +```clojure +Language +``` + +### yiddish + +```clojure +Language +``` + +### yoruba + +```clojure +Language +``` + +### yupik + +```clojure +Language +``` + +### zande + +```clojure +Language +``` + +### zapotec + +```clojure +Language +``` + +### zaza + +```clojure +Language +``` + +### zazaki + +```clojure +Language +``` + +### zenaga + +```clojure +Language +``` + +### zhuang + +```clojure +Language +``` + +### zulu + +```clojure +Language +``` + +### zuni + +```clojure +Language +``` + +___ + +# library/lux/locale/territory + +## Definitions + +### Territory + +```clojure +... .Type +(primitive "library/lux/locale/territory.Territory") +``` + +An ISO 3166 territory\. + +### afghanistan + +```clojure +Territory +``` + +### aland\_islands + +```clojure +Territory +``` + +### albania + +```clojure +Territory +``` + +### algeria + +```clojure +Territory +``` + +### american\_samoa + +```clojure +Territory +``` + +### andorra + +```clojure +Territory +``` + +### angola + +```clojure +Territory +``` + +### anguilla + +```clojure +Territory +``` + +### antarctica + +```clojure +Territory +``` + +### antigua + +```clojure +Territory +``` + +### argentina + +```clojure +Territory +``` + +### armenia + +```clojure +Territory +``` + +### aruba + +```clojure +Territory +``` + +### ascension + +```clojure +Territory +``` + +### australia + +```clojure +Territory +``` + +### austria + +```clojure +Territory +``` + +### azerbaijan + +```clojure +Territory +``` + +### bahrain + +```clojure +Territory +``` + +### bangladesh + +```clojure +Territory +``` + +### barbados + +```clojure +Territory +``` + +### barbuda + +```clojure +Territory +``` + +### belarus + +```clojure +Territory +``` + +### belgium + +```clojure +Territory +``` + +### belize + +```clojure +Territory +``` + +### benin + +```clojure +Territory +``` + +### bermuda + +```clojure +Territory +``` + +### bhutan + +```clojure +Territory +``` + +### bolivia + +```clojure +Territory +``` + +### bonaire + +```clojure +Territory +``` + +### bosnia + +```clojure +Territory +``` + +### botswana + +```clojure +Territory +``` + +### bouvet\_island + +```clojure +Territory +``` + +### brazil + +```clojure +Territory +``` + +### british\_indian\_ocean\_territory + +```clojure +Territory +``` + +### british\_virgin\_islands + +```clojure +Territory +``` + +### brunei\_darussalam + +```clojure +Territory +``` + +### bulgaria + +```clojure +Territory +``` + +### burkina\_faso + +```clojure +Territory +``` + +### burundi + +```clojure +Territory +``` + +### caicos\_islands + +```clojure +Territory +``` + +### cambodia + +```clojure +Territory +``` + +### cameroon + +```clojure +Territory +``` + +### canada + +```clojure +Territory +``` + +### cape\_verde + +```clojure +Territory +``` + +### cayman\_islands + +```clojure +Territory +``` + +### central\_african\_republic + +```clojure +Territory +``` + +### chad + +```clojure +Territory +``` + +### chile + +```clojure +Territory +``` + +### china + +```clojure +Territory +``` + +### christmas\_island + +```clojure +Territory +``` + +### cocos\_islands + +```clojure +Territory +``` + +### colombia + +```clojure +Territory +``` + +### comoros + +```clojure +Territory +``` + +### congo + +```clojure +Territory +``` + +### cook\_islands + +```clojure +Territory +``` + +### costa\_rica + +```clojure +Territory +``` + +### croatia + +```clojure +Territory +``` + +### cuba + +```clojure +Territory +``` + +### curacao + +```clojure +Territory +``` + +### cyprus + +```clojure +Territory +``` + +### czech\_republic + +```clojure +Territory +``` + +### democratic\_republic\_of\_the\_congo + +```clojure +Territory +``` + +### denmark + +```clojure +Territory +``` + +### djibouti + +```clojure +Territory +``` + +### dominica + +```clojure +Territory +``` + +### dominican\_republic + +```clojure +Territory +``` + +### east\_timor + +```clojure +Territory +``` + +### ecuador + +```clojure +Territory +``` + +### egypt + +```clojure +Territory +``` + +### el\_salvador + +```clojure +Territory +``` + +### equatorial\_guinea + +```clojure +Territory +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Territory) +``` + +### eritrea + +```clojure +Territory +``` + +### estonia + +```clojure +Territory +``` + +### eswatini + +```clojure +Territory +``` + +### ethiopia + +```clojure +Territory +``` + +### falkland\_islands + +```clojure +Territory +``` + +### faroe\_islands + +```clojure +Territory +``` + +### fiji + +```clojure +Territory +``` + +### finland + +```clojure +Territory +``` + +### france + +```clojure +Territory +``` + +### french\_guiana + +```clojure +Territory +``` + +### french\_polynesia + +```clojure +Territory +``` + +### french\_southern\_territories + +```clojure +Territory +``` + +### futuna + +```clojure +Territory +``` + +### gabon + +```clojure +Territory +``` + +### georgia + +```clojure +Territory +``` + +### germany + +```clojure +Territory +``` + +### ghana + +```clojure +Territory +``` + +### gibraltar + +```clojure +Territory +``` + +### greece + +```clojure +Territory +``` + +### greenland + +```clojure +Territory +``` + +### grenada + +```clojure +Territory +``` + +### guadeloupe + +```clojure +Territory +``` + +### guam + +```clojure +Territory +``` + +### guatemala + +```clojure +Territory +``` + +### guernsey + +```clojure +Territory +``` + +### guinea + +```clojure +Territory +``` + +### guinea\_bissau + +```clojure +Territory +``` + +### guyana + +```clojure +Territory +``` + +### haiti + +```clojure +Territory +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash Territory) +``` + +### heard\_island + +```clojure +Territory +``` + +### herzegovina + +```clojure +Territory +``` + +### honduras + +```clojure +Territory +``` + +### hong\_kong + +```clojure +Territory +``` + +### hungary + +```clojure +Territory +``` + +### iceland + +```clojure +Territory +``` + +### india + +```clojure +Territory +``` + +### indonesia + +```clojure +Territory +``` + +### iran + +```clojure +Territory +``` + +### iraq + +```clojure +Territory +``` + +### ireland + +```clojure +Territory +``` + +### isle\_of\_man + +```clojure +Territory +``` + +### israel + +```clojure +Territory +``` + +### italy + +```clojure +Territory +``` + +### ivory\_coast + +```clojure +Territory +``` + +### jamaica + +```clojure +Territory +``` + +### jan\_mayen + +```clojure +Territory +``` + +### japan + +```clojure +Territory +``` + +### jersey + +```clojure +Territory +``` + +### jordan + +```clojure +Territory +``` + +### kazakhstan + +```clojure +Territory +``` + +### kenya + +```clojure +Territory +``` + +### kiribati + +```clojure +Territory +``` + +### kuwait + +```clojure +Territory +``` + +### kyrgyzstan + +```clojure +Territory +``` + +### laos + +```clojure +Territory +``` + +### latvia + +```clojure +Territory +``` + +### lebanon + +```clojure +Territory +``` + +### lesotho + +```clojure +Territory +``` + +### liberia + +```clojure +Territory +``` + +### libya + +```clojure +Territory +``` + +### liechtenstein + +```clojure +Territory +``` + +### lithuania + +```clojure +Territory +``` + +### long\_code + +```clojure +(-> Territory .Text) +``` + +### luxembourg + +```clojure +Territory +``` + +### macau + +```clojure +Territory +``` + +### macedonia + +```clojure +Territory +``` + +### madagascar + +```clojure +Territory +``` + +### malawi + +```clojure +Territory +``` + +### malaysia + +```clojure +Territory +``` + +### maldives + +```clojure +Territory +``` + +### mali + +```clojure +Territory +``` + +### malta + +```clojure +Territory +``` + +### marshall\_islands + +```clojure +Territory +``` + +### martinique + +```clojure +Territory +``` + +### mauritania + +```clojure +Territory +``` + +### mauritius + +```clojure +Territory +``` + +### mayotte + +```clojure +Territory +``` + +### mcdonald\_islands + +```clojure +Territory +``` + +### mexico + +```clojure +Territory +``` + +### micronesia + +```clojure +Territory +``` + +### miquelon + +```clojure +Territory +``` + +### moldova + +```clojure +Territory +``` + +### monaco + +```clojure +Territory +``` + +### mongolia + +```clojure +Territory +``` + +### montenegro + +```clojure +Territory +``` + +### montserrat + +```clojure +Territory +``` + +### morocco + +```clojure +Territory +``` + +### mozambique + +```clojure +Territory +``` + +### myanmar + +```clojure +Territory +``` + +### name + +```clojure +(-> Territory .Text) +``` + +### namibia + +```clojure +Territory +``` + +### nauru + +```clojure +Territory +``` + +### nepal + +```clojure +Territory +``` + +### netherlands + +```clojure +Territory +``` + +### nevis + +```clojure +Territory +``` + +### new\_caledonia + +```clojure +Territory +``` + +### new\_zealand + +```clojure +Territory +``` + +### nicaragua + +```clojure +Territory +``` + +### niger + +```clojure +Territory +``` + +### nigeria + +```clojure +Territory +``` + +### niue + +```clojure +Territory +``` + +### norfolk\_island + +```clojure +Territory +``` + +### north\_korea + +```clojure +Territory +``` + +### northern\_ireland + +```clojure +Territory +``` + +### northern\_mariana\_islands + +```clojure +Territory +``` + +### norway + +```clojure +Territory +``` + +### numeric\_code + +```clojure +(-> Territory .Nat) +``` + +### oman + +```clojure +Territory +``` + +### pakistan + +```clojure +Territory +``` + +### palau + +```clojure +Territory +``` + +### palestine + +```clojure +Territory +``` + +### panama + +```clojure +Territory +``` + +### papua\_new\_guinea + +```clojure +Territory +``` + +### paraguay + +```clojure +Territory +``` + +### peru + +```clojure +Territory +``` + +### philippines + +```clojure +Territory +``` + +### pitcairn\_islands + +```clojure +Territory +``` + +### poland + +```clojure +Territory +``` + +### portugal + +```clojure +Territory +``` + +### principe + +```clojure +Territory +``` + +### puerto\_rico + +```clojure +Territory +``` + +### qatar + +```clojure +Territory +``` + +### reunion + +```clojure +Territory +``` + +### romania + +```clojure +Territory +``` + +### russia + +```clojure +Territory +``` + +### rwanda + +```clojure +Territory +``` + +### saba + +```clojure +Territory +``` + +### saint\_barthelemy + +```clojure +Territory +``` + +### saint\_helena + +```clojure +Territory +``` + +### saint\_kitts + +```clojure +Territory +``` + +### saint\_lucia + +```clojure +Territory +``` + +### saint\_martin + +```clojure +Territory +``` + +### saint\_pierre + +```clojure +Territory +``` + +### saint\_vincent + +```clojure +Territory +``` + +### samoa + +```clojure +Territory +``` + +### san\_marino + +```clojure +Territory +``` + +### sao\_tome + +```clojure +Territory +``` + +### saudi\_arabia + +```clojure +Territory +``` + +### senegal + +```clojure +Territory +``` + +### serbia + +```clojure +Territory +``` + +### seychelles + +```clojure +Territory +``` + +### short\_code + +```clojure +(-> Territory .Text) +``` + +### sierra\_leone + +```clojure +Territory +``` + +### singapore + +```clojure +Territory +``` + +### sint\_eustatius + +```clojure +Territory +``` + +### sint\_maarten + +```clojure +Territory +``` + +### slovakia + +```clojure +Territory +``` + +### slovenia + +```clojure +Territory +``` + +### solomon\_islands + +```clojure +Territory +``` + +### somalia + +```clojure +Territory +``` + +### south\_africa + +```clojure +Territory +``` + +### south\_georgia + +```clojure +Territory +``` + +### south\_korea + +```clojure +Territory +``` + +### south\_sandwich\_islands + +```clojure +Territory +``` + +### south\_sudan + +```clojure +Territory +``` + +### spain + +```clojure +Territory +``` + +### sri\_lanka + +```clojure +Territory +``` + +### sudan + +```clojure +Territory +``` + +### suriname + +```clojure +Territory +``` + +### svalbard + +```clojure +Territory +``` + +### sweden + +```clojure +Territory +``` + +### switzerland + +```clojure +Territory +``` + +### syria + +```clojure +Territory +``` + +### taiwan + +```clojure +Territory +``` + +### tajikistan + +```clojure +Territory +``` + +### tanzania + +```clojure +Territory +``` + +### thailand + +```clojure +Territory +``` + +### the\_bahamas + +```clojure +Territory +``` + +### the\_gambia + +```clojure +Territory +``` + +### the\_grenadines + +```clojure +Territory +``` + +### tobago + +```clojure +Territory +``` + +### togo + +```clojure +Territory +``` + +### tokelau + +```clojure +Territory +``` + +### tonga + +```clojure +Territory +``` + +### trinidad + +```clojure +Territory +``` + +### tristan\_da\_cunha + +```clojure +Territory +``` + +### tunisia + +```clojure +Territory +``` + +### turkey + +```clojure +Territory +``` + +### turkmenistan + +```clojure +Territory +``` + +### turks + +```clojure +Territory +``` + +### tuvalu + +```clojure +Territory +``` + +### uganda + +```clojure +Territory +``` + +### ukraine + +```clojure +Territory +``` + +### united\_arab\_emirates + +```clojure +Territory +``` + +### united\_kingdom + +```clojure +Territory +``` + +### united\_states\_minor\_outlying\_islands + +```clojure +Territory +``` + +### united\_states\_of\_america + +```clojure +Territory +``` + +### united\_states\_virgin\_islands + +```clojure +Territory +``` + +### uruguay + +```clojure +Territory +``` + +### uzbekistan + +```clojure +Territory +``` + +### vanuatu + +```clojure +Territory +``` + +### vatican\_city + +```clojure +Territory +``` + +### venezuela + +```clojure +Territory +``` + +### vietnam + +```clojure +Territory +``` + +### wallis + +```clojure +Territory +``` + +### western\_sahara + +```clojure +Territory +``` + +### yemen + +```clojure +Territory +``` + +### zambia + +```clojure +Territory +``` + +### zimbabwe + +```clojure +Territory +``` + +___ + +# library/lux/macro + +## Definitions + +### expansion + +```clojure +(-> .Code (.Meta (.List .Code))) +``` + +Given code that requires applying a macro, expands repeatedly until no more direct macro\-calls are left\. +Otherwise, returns the code as\-is\. + +```clojure +(expansion syntax) +``` + +### full\_expansion + +```clojure +(-> .Code (.Meta (.List .Code))) +``` + +Expands all macro\-calls everywhere recursively, until only primitive/base code remains\. + +```clojure +(full_expansion syntax) +``` + +### identifier + +```clojure +(-> .Text (.Meta .Code)) +``` + +Generates a unique name as an Code node \(ready to be used in code templates\)\. +A prefix can be given \(or just be empty text\) to better identify the code for debugging purposes\. + +```clojure +(identifier prefix) +``` + +### log\_expansion\! + +```clojure +.Macro +``` + +Performs a macro\-expansion and logs the resulting code\. +You can either use the resulting code, or omit them\. +By omitting them, this macro produces nothing \(just like the lux\.comment macro\)\. + +```clojure + ( + + + + + +log_expansion! #omit + (def: (foo bar baz) + (-> Int Int Int) + (int.+ bar baz))) +``` + +### log\_full\_expansion\! + +```clojure +.Macro +``` + +Performs a macro\-expansion and logs the resulting code\. +You can either use the resulting code, or omit them\. +By omitting them, this macro produces nothing \(just like the lux\.comment macro\)\. + +```clojure + ( + + + + + + +log_full_expansion! #omit + (def: (foo bar baz) + (-> Int Int Int) + (int.+ bar baz))) +``` + +### log\_single\_expansion\! + +```clojure +.Macro +``` + +Performs a macro\-expansion and logs the resulting code\. +You can either use the resulting code, or omit them\. +By omitting them, this macro produces nothing \(just like the lux\.comment macro\)\. + +```clojure + ( + + + + +log_single_expansion! #omit + (def: (foo bar baz) + (-> Int Int Int) + (int.+ bar baz))) +``` + +### one\_expansion + +```clojure +(-> .Code (.Meta .Code)) +``` + +Works just like expand, except that it ensures that the output is a single Code token\. + +```clojure +(one_expansion token) +``` + +### single\_expansion + +```clojure +(-> .Code (.Meta (.List .Code))) +``` + +Given code that requires applying a macro, does it once and returns the result\. +Otherwise, returns the code as\-is\. + +```clojure +(single_expansion syntax) +``` + +### with\_identifiers + +```clojure +.Macro +``` + +Creates new identifiers and offers them to the body expression\. + +```clojure +(syntax: (synchronized [lock any + body any]) + (with_identifiers [g!lock g!body g!_] + (in (list (` (let [(~ g!lock) (~ lock) + (~ g!_) ("jvm monitorenter" (~ g!lock)) + (~ g!body) (~ body) + (~ g!_) ("jvm monitorexit" (~ g!lock))] + (~ g!body))))))) +``` + +### wrong\_syntax\_error + +```clojure +(-> .Name .Text) +``` + +A generic error message for macro syntax failures\. + +___ + +# library/lux/macro/code + +## Definitions + +### bit + +```clojure +(-> .Bit .Code) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Code) +``` + +### form + +```clojure +(-> (.List .Code) .Code) +``` + +### format + +```clojure +(-> .Code .Text) +``` + +### frac + +```clojure +(-> .Frac .Code) +``` + +### identifier + +```clojure +(-> .Name .Code) +``` + +### int + +```clojure +(-> .Int .Code) +``` + +### local\_identifier + +```clojure +(-> .Text .Code) +``` + +Produces a local identifier \(an identifier with no module prefix\)\. + +### local\_tag + +```clojure +(-> .Text .Code) +``` + +Produces a local tag \(a tag with no module prefix\)\. + +### nat + +```clojure +(-> .Nat .Code) +``` + +### record + +```clojure +(-> (.List [.Code .Code]) .Code) +``` + +### replaced + +```clojure +(-> .Code .Code .Code .Code) +``` + +```clojure +(replaced original substitute ast) +``` + +### rev + +```clojure +(-> .Rev .Code) +``` + +### tag + +```clojure +(-> .Name .Code) +``` + +### text + +```clojure +(-> .Text .Code) +``` + +### tuple + +```clojure +(-> (.List .Code) .Code) +``` + +___ + +# library/lux/macro/local + +## Definitions + +### cannot\_shadow\_definition + +```clojure +(library/lux/control/exception.Exception [.Text .Text]) +``` + +### push + +```clojure +(-> (.List [.Name .Macro]) (.Meta .Code)) +``` + +Installs macros in the compiler\-state, with the given names\. +Yields code that can be placed either as expression or as directives\. +This code un\-installs the macros\. +NOTE: Always use this code once to clean\-up\.\. + +```clojure +(push macros) +``` + +### unknown\_definition + +```clojure +(library/lux/control/exception.Exception [.Text .Text]) +``` + +### unknown\_module + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +___ + +# library/lux/macro/syntax + +## Definitions + +### syntax: + +```clojure +.Macro +``` + + +A more advanced way to define macros than 'macro:'\. +The inputs to the macro can be parsed in complex ways through the use of syntax parsers\. +The macro body is also \(implicitly\) run in the Meta monad, to save some typing\. +Also, the compiler state can be accessed through the \*lux\* binding\. + +```clojure +(syntax: .public(object [.let[imports (class_imports *lux*)] + .let[class_vars (list)] + super (opt (super_class_decl^ imports class_vars)) + interfaces (tuple (some (super_class_decl^ imports class_vars))) + constructor_args (constructor_args^ imports class_vars) + methods (some (overriden_method_def^ imports))]) + (let [def_code ($_ text\composite "anon-class:" + (spaced (list (super_class_decl$ (maybe.else object_super_class super)) + (with_brackets (spaced (list\each super_class_decl$ interfaces))) + (with_brackets (spaced (list\each constructor_arg$ constructor_args))) + (with_brackets (spaced (list\each (method_def$ id) methods))))))] + (in (list (` ((~ (code.text def_code)))))))) +``` + +___ + +# library/lux/macro/syntax/annotations + +## Definitions + +### Annotations + +```clojure +... .Type +(.List [.Name .Code]) +``` + +Definition/module annotations\. + +### empty + +```clojure +Annotations +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Annotations) +``` + +### format + +```clojure +(-> Annotations .Code) +``` + +### parser + +```clojure +(library/lux/control/parser/code.Parser Annotations) +``` + +___ + +# library/lux/macro/syntax/check + +## Definitions + +### Check + +```clojure +... .Type +[.Code .Code] +``` + +A type annotation for an expression\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Check) +``` + +### format + +```clojure +(-> Check .Code) +``` + +### parser + +```clojure +(library/lux/control/parser/code.Parser Check) +``` + +___ + +# library/lux/macro/syntax/declaration + +## Definitions + +### Declaration + +```clojure +... .Type +[.Text (.List .Text)] +``` + +A declaration for either a constant or a function\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Declaration) +``` + +### format + +```clojure +(-> Declaration .Code) +``` + +### parser + +```clojure +(library/lux/control/parser/code.Parser Declaration) +``` + +A parser for declaration syntax\. + +```clojure +... Such as: + +quux + +(foo bar baz) +``` + +___ + +# library/lux/macro/syntax/definition + +## Definitions + +### Definition + +```clojure +... .Type +[.Text (.Either library/lux/macro/syntax/check.Check .Code) library/lux/macro/syntax/annotations.Annotations .Bit] +``` + +Syntax for a constant definition\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Definition) +``` + +### format + +```clojure +(-> Definition .Code) +``` + +### lacks\_type + +```clojure +(library/lux/control/exception.Exception Definition) +``` + +### parser + +```clojure +(-> .Lux (library/lux/control/parser/code.Parser Definition)) +``` + +A reader that first macro\-expands and then analyses the input Code, to ensure it is a definition\. + +```clojure +(parser compiler) +``` + +### typed + +```clojure +(-> .Lux (library/lux/control/parser/code.Parser Definition)) +``` + +Only works for typed definitions\. + +```clojure +(typed compiler) +``` + +___ + +# library/lux/macro/syntax/export + +Syntax for marking a definition as an export\. + +## Definitions + +### default\_policy + +```clojure +.Code +``` + +### parser + +```clojure +(All (_ a) (-> (library/lux/control/parser/code.Parser a) (library/lux/control/parser/code.Parser [.Code a]))) +``` + +```clojure +(parser un_exported) +``` + +___ + +# library/lux/macro/syntax/input + +## Definitions + +### Input + +```clojure +... .Type +[.Code .Code] +``` + +The common typed\-argument syntax used by many macros\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Input) +``` + +### format + +```clojure +(-> Input .Code) +``` + +### parser + +```clojure +(library/lux/control/parser/code.Parser Input) +``` + +Parser for the common typed\-argument syntax used by many macros\. + +___ + +# library/lux/macro/syntax/type/variable + +## Definitions + +### Variable + +```clojure +... .Type +(primitive "#Text") +``` + +A variable'S name\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Variable) +``` + +### format + +```clojure +(-> Variable .Code) +``` + +### parser + +```clojure +(library/lux/control/parser/code.Parser Variable) +``` + +Parser for the common type variable/parameter used by many macros\. + +___ + +# library/lux/macro/template + +Utilities commonly used while templating\. + +## Definitions + +### amount + +```clojure +.Macro +``` + +```clojure +(amount [a b c d]) + +... => + +4 +``` + +### identifier + +```clojure +.Macro +``` + +An identifier made by concatenating pieces of code\. +The \(optional\) module part and the short part are specified independently\. + +```clojure +( + + + + + + + identifier ["abc" .defdocumentation/lux/macro/template.ghi]) + +... => + +abcdefghi + +................................................................ +................................................................ + +( + + + + identifier [.def]["abc" .defdocumentation/lux/macro/template.ghi]) + +... => + +.abcdefghi +``` + +### irregular\_arguments + +```clojure +(library/lux/control/exception.Exception [.Nat .Nat]) +``` + +### let + +```clojure +.Macro +``` + +Lexically\-bound templates\. + +```clojure +(let [(!square <root>) + [(* <root> <root>)]] + (def: (square root) + (-> Nat Nat) + (!square root))) +``` + +### spliced + +```clojure +.Macro +``` + +```clojure +(spliced [a b c d]) + +... => + +a + +b + +c + +d +``` + +### tag + +```clojure +.Macro +``` + +A tag made by concatenating pieces of code\. +The \(optional\) module part and the short part are specified independently\. + +```clojure +( + + + + + + + + tag ["abc" .defdocumentation/lux/macro/template.ghi]) + +... => + +#abcdefghi + +................................................................ +................................................................ + +( + + + + + tag [.def]["abc" .defdocumentation/lux/macro/template.ghi]) + +... => + +#library/lux.abcdefghi +``` + +### text + +```clojure +.Macro +``` + +A text literal made by concatenating pieces of code\. + +```clojure +(text [#0 123 +456 +789.0 "abc" .defdocumentation/lux/macro/template.ghi]) + +... => + +... #0123+456+789.0abcdefghi +``` + +### with\_locals + +```clojure +.Macro +``` + +Creates names for local bindings aliased by the names you choose\. + +```clojure +(with_locals [my_var] + (let [my_var 123] + (text [my_var]))) + +... => + +... __gensym__my_var506 +``` + +___ + +# library/lux/math + +Common mathematical constants and functions\. + +## Definitions + +### acos + +```clojure +(-> .Frac .Frac) +``` + +### acosh + +```clojure +(-> .Frac .Frac) +``` + +### acoth + +```clojure +(-> .Frac .Frac) +``` + +### acsch + +```clojure +(-> .Frac .Frac) +``` + +### asech + +```clojure +(-> .Frac .Frac) +``` + +### asin + +```clojure +(-> .Frac .Frac) +``` + +### asinh + +```clojure +(-> .Frac .Frac) +``` + +### atan + +```clojure +(-> .Frac .Frac) +``` + +### atan/2 + +```clojure +(-> .Frac .Frac .Frac) +``` + +```clojure +(atan/2 x y) +``` + +### atanh + +```clojure +(-> .Frac .Frac) +``` + +### ceil + +```clojure +(-> .Frac .Frac) +``` + +### cos + +```clojure +(-> .Frac .Frac) +``` + +### cosh + +```clojure +(-> .Frac .Frac) +``` + +### coth + +```clojure +(-> .Frac .Frac) +``` + +### csch + +```clojure +(-> .Frac .Frac) +``` + +### e + +```clojure +.Frac +``` + +The base of the natural logarithm\. + +### exp + +```clojure +(-> .Frac .Frac) +``` + +### factorial + +```clojure +(-> .Nat .Nat) +``` + +### floor + +```clojure +(-> .Frac .Frac) +``` + +### hypotenuse + +```clojure +(-> .Frac .Frac .Frac) +``` + +### log + +```clojure +(-> .Frac .Frac) +``` + +### log\_by + +```clojure +(-> .Frac .Frac .Frac) +``` + +```clojure +(log_by base it) +``` + +### pi + +```clojure +.Frac +``` + +The ratio of a circle's circumference to its diameter\. + +### pow + +```clojure +(-> .Frac .Frac .Frac) +``` + +```clojure +(pow param subject) +``` + +### root/2 + +```clojure +(-> .Frac .Frac) +``` + +### root/3 + +```clojure +(-> .Frac .Frac) +``` + +### round + +```clojure +(-> .Frac .Frac) +``` + +### sech + +```clojure +(-> .Frac .Frac) +``` + +### sin + +```clojure +(-> .Frac .Frac) +``` + +### sinh + +```clojure +(-> .Frac .Frac) +``` + +### tan + +```clojure +(-> .Frac .Frac) +``` + +### tanh + +```clojure +(-> .Frac .Frac) +``` + +### tau + +```clojure +.Frac +``` + +The ratio of a circle's circumference to its radius\. + +___ + +# library/lux/math/infix + +## Definitions + +### infix + +```clojure +.Macro +``` + +Infix math syntax\. +The rules for infix syntax are simple\. +If you want your binary function to work well with it\. +Then take the argument to the right \(y\) as your first argument, +and take the argument to the left \(x\) as your second argument\. + +```clojure +(infix [x * +10]) + +................................................................ +................................................................ + +(infix [[x + y] * [x - y]]) + +................................................................ +................................................................ + +(infix [sin [x + y]]) + +................................................................ +................................................................ + +(infix [[x < y] and [y < z]]) + +................................................................ +................................................................ + +(infix [#and x < y < z]) + +................................................................ +................................................................ + +(infix [(* 3 9) gcd 450]) +``` + +___ + +# library/lux/math/logic/continuous + +Continuous logic using Rev values\. +Continuous logic is logic in the interval \[0,1\] instead of just the binary \#0 and \#1 options\. +Because Rev is being used, the interval is actual \[0,1\)\. + +## Definitions + +### = + +```clojure +(-> .Rev .Rev .Rev) +``` + +### and + +```clojure +(-> .Rev .Rev .Rev) +``` + +### conjunction + +```clojure +(library/lux/abstract/monoid.Monoid .Rev) +``` + +### disjunction + +```clojure +(library/lux/abstract/monoid.Monoid .Rev) +``` + +### false + +```clojure +.Rev +``` + +### implies + +```clojure +(-> .Rev .Rev .Rev) +``` + +```clojure +(implies consequent antecedent) +``` + +### not + +```clojure +(-> .Rev .Rev) +``` + +### or + +```clojure +(-> .Rev .Rev .Rev) +``` + +### true + +```clojure +.Rev +``` + +___ + +# library/lux/math/logic/fuzzy + +Fuzzy logic, implemented on top of the Rev type\. + +## Definitions + +### \(Fuzzy it\) + +```clojure +... .Type +(-> it .Rev) +``` + +A fuzzy set\. + +### complement + +```clojure +(All (_ a) (-> (Fuzzy a) (Fuzzy a))) +``` + +### cut + +```clojure +(All (_ a) (-> .Rev (Fuzzy a) (Fuzzy a))) +``` + +```clojure +(cut treshold set) +``` + +### difference + +```clojure +(All (_ a) (-> (Fuzzy a) (Fuzzy a) (Fuzzy a))) +``` + +```clojure +(difference sub base) +``` + +### empty + +```clojure +Fuzzy +``` + +### full + +```clojure +Fuzzy +``` + +### functor + +```clojure +(library/lux/abstract/functor/contravariant.Functor Fuzzy) +``` + +### gradient + +```clojure +(-> .Rev .Rev (Fuzzy .Rev)) +``` + +```clojure +(gradient from to) +``` + +### intersection + +```clojure +(All (_ a) (-> (Fuzzy a) (Fuzzy a) (Fuzzy a))) +``` + +### membership + +```clojure +(All (_ a) (-> (Fuzzy a) a .Rev)) +``` + +```clojure +(membership set elem) +``` + +### of\_predicate + +```clojure +(All (_ a) (-> (library/lux/abstract/predicate.Predicate a) (Fuzzy a))) +``` + +```clojure +(of_predicate predicate) +``` + +### of\_set + +```clojure +(All (_ a) (-> (library/lux/data/collection/set.Set a) (Fuzzy a))) +``` + +### predicate + +```clojure +(All (_ a) (-> .Rev (Fuzzy a) (library/lux/abstract/predicate.Predicate a))) +``` + +```clojure +(predicate treshold set) +``` + +### trapezoid + +```clojure +(-> .Rev .Rev .Rev .Rev (Fuzzy .Rev)) +``` + +```clojure +(trapezoid bottom middle_bottom middle_top top) +``` + +### triangle + +```clojure +(-> .Rev .Rev .Rev (Fuzzy .Rev)) +``` + +```clojure +(triangle bottom middle top) +``` + +### union + +```clojure +(All (_ a) (-> (Fuzzy a) (Fuzzy a) (Fuzzy a))) +``` + +___ + +# library/lux/math/modular + +## Definitions + +### \* + +```clojure +(All (_ a) (-> (Mod a) (Mod a) (Mod a))) +``` + +### \+ + +```clojure +(All (_ a) (-> (Mod a) (Mod a) (Mod a))) +``` + +### \- + +```clojure +(All (_ a) (-> (Mod a) (Mod a) (Mod a))) +``` + +### < + +```clojure +(All (_ a) (-> (Mod a) (Mod a) .Bit)) +``` + +### <= + +```clojure +(All (_ a) (-> (Mod a) (Mod a) .Bit)) +``` + +### = + +```clojure +(All (_ a) (-> (Mod a) (Mod a) .Bit)) +``` + +### > + +```clojure +(All (_ a) (-> (Mod a) (Mod a) .Bit)) +``` + +### >= + +```clojure +(All (_ a) (-> (Mod a) (Mod a) .Bit)) +``` + +### \(Mod %\) + +```clojure +... .Type +(primitive "library/lux/math/modular.Mod" %) +``` + +A number under a modulus\. + +### adapter + +```clojure +(All (_ a b) (-> (library/lux/math/modulus.Modulus a) (library/lux/math/modulus.Modulus b) (library/lux/control/try.Try (-> (Mod b) (Mod a))))) +``` + +```clojure +(adapter reference subject) +``` + +### addition + +```clojure +(All (_ a) (-> (library/lux/math/modulus.Modulus a) (library/lux/abstract/monoid.Monoid (Mod a)))) +``` + +### codec + +```clojure +(All (_ a) (-> (library/lux/math/modulus.Modulus a) (library/lux/abstract/codec.Codec .Text (Mod a)))) +``` + +### equivalence + +```clojure +(All (_ a) (library/lux/abstract/equivalence.Equivalence (Mod a))) +``` + +### incorrect\_modulus + +```clojure +(All (_ a) (library/lux/control/exception.Exception [(library/lux/math/modulus.Modulus a) .Int])) +``` + +### inverse + +```clojure +(All (_ a) (-> (Mod a) (.Maybe (Mod a)))) +``` + +### modular + +```clojure +(All (_ a) (-> (library/lux/math/modulus.Modulus a) .Int (Mod a))) +``` + +```clojure +(modular modulus value) +``` + +### moduli\_are\_not\_equal + +```clojure +(All (_ a b) (library/lux/control/exception.Exception [(library/lux/math/modulus.Modulus a) (library/lux/math/modulus.Modulus b)])) +``` + +### modulus + +```clojure +(All (_ a) (-> (Mod a) (library/lux/math/modulus.Modulus a))) +``` + +### multiplication + +```clojure +(All (_ a) (-> (library/lux/math/modulus.Modulus a) (library/lux/abstract/monoid.Monoid (Mod a)))) +``` + +### order + +```clojure +(All (_ a) (library/lux/abstract/order.Order (Mod a))) +``` + +### value + +```clojure +(All (_ a) (-> (Mod a) .Int)) +``` + +___ + +# library/lux/math/modulus + +## Definitions + +### = + +```clojure +(All (_ a b) (-> (Modulus a) (Modulus b) .Bit)) +``` + +### \(Modulus %\) + +```clojure +... .Type +(primitive "library/lux/math/modulus.Modulus" %) +``` + +A number used as a modulus in modular arithmetic\. +It cannot be 0\. + +### congruent? + +```clojure +(All (_ a) (-> (Modulus a) .Int .Int .Bit)) +``` + +```clojure +(congruent? modulus reference subject) +``` + +### divisor + +```clojure +(All (_ a) (-> (Modulus a) .Int)) +``` + +### literal + +```clojure +.Macro +``` + +```clojure +... Success! + +(literal 123) + +................................................................ +................................................................ + +... Failure! + +(literal 0) +``` + +### modulus + +```clojure +(Ex (_ a) (-> .Int (library/lux/control/try.Try (Modulus a)))) +``` + +### zero\_cannot\_be\_a\_modulus + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +___ + +# library/lux/math/number + +## Definitions + +### bin + +```clojure +.Macro +``` + +Given syntax for a binary number, generates a Nat, an Int, a Rev or a Frac\. + +```clojure +(bin "11001001") + +................................................................ +................................................................ + +... Allows for the presence of commas (,) among the digits. + +(bin "11,00,10,01") +``` + +### hex + +```clojure +.Macro +``` + +Given syntax for a hexadecimal number, generates a Nat, an Int, a Rev or a Frac\. + +```clojure +(hex "deadBEEF") + +................................................................ +................................................................ + +... Allows for the presence of commas (,) among the digits. + +(hex "dead,BEEF") +``` + +### oct + +```clojure +.Macro +``` + +Given syntax for a octal number, generates a Nat, an Int, a Rev or a Frac\. + +```clojure +(oct "615243") + +................................................................ +................................................................ + +... Allows for the presence of commas (,) among the digits. + +(oct "615,243") +``` + +___ + +# library/lux/math/number/complex + +Complex arithmetic\. + +## Definitions + +### % + +```clojure +(-> Complex Complex Complex) +``` + +### \* + +```clojure +(-> Complex Complex Complex) +``` + +### \*' + +```clojure +(-> .Frac Complex Complex) +``` + +### \+ + +```clojure +(-> Complex Complex Complex) +``` + +### \+one + +```clojure +[.Frac .Frac] +``` + +### \- + +```clojure +(-> Complex Complex Complex) +``` + +### \-one + +```clojure +[.Frac .Frac] +``` + +### / + +```clojure +(-> Complex Complex Complex) +``` + +### /' + +```clojure +(-> .Frac Complex Complex) +``` + +### = + +```clojure +(-> Complex Complex .Bit) +``` + +### Complex + +```clojure +... .Type +[.Frac .Frac] +``` + +A complex number\. + +### abs + +```clojure +(-> Complex .Frac) +``` + +### acos + +```clojure +(-> Complex Complex) +``` + +### approximately? + +```clojure +(-> .Frac Complex Complex .Bit) +``` + +### argument + +```clojure +(-> Complex .Frac) +``` + +### asin + +```clojure +(-> Complex Complex) +``` + +### atan + +```clojure +(-> Complex Complex) +``` + +### complex + +```clojure +.Macro +``` + +Complex literals\. + +```clojure +(complex real imaginary) + +................................................................ +................................................................ + +... The imaginary part can be omitted if it's +0.0. + +(complex real) +``` + +### conjugate + +```clojure +(-> Complex Complex) +``` + +### cos + +```clojure +(-> Complex Complex) +``` + +### cosh + +```clojure +(-> Complex Complex) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Complex) +``` + +### exp + +```clojure +(-> Complex Complex) +``` + +### i + +```clojure +[.Frac .Frac] +``` + +### log + +```clojure +(-> Complex Complex) +``` + +### not\_a\_number? + +```clojure +(-> Complex .Bit) +``` + +### opposite + +```clojure +(-> Complex Complex) +``` + +### pow + +```clojure +(-> Complex Complex Complex) +``` + +### pow' + +```clojure +(-> .Frac Complex Complex) +``` + +### reciprocal + +```clojure +(-> Complex Complex) +``` + +### root/2 + +```clojure +(-> Complex Complex) +``` + +### roots + +```clojure +(-> .Nat Complex (.List Complex)) +``` + +### signum + +```clojure +(-> Complex Complex) +``` + +### sin + +```clojure +(-> Complex Complex) +``` + +### sinh + +```clojure +(-> Complex Complex) +``` + +### tan + +```clojure +(-> Complex Complex) +``` + +### tanh + +```clojure +(-> Complex Complex) +``` + +### zero + +```clojure +[.Frac .Frac] +``` + +___ + +# library/lux/math/number/frac + +## Definitions + +### % + +```clojure +(-> .Frac .Frac .Frac) +``` + +Frac\(tion\) remainder\. + +```clojure + ( + + + + + +% param subject) +``` + +### \* + +```clojure +(-> .Frac .Frac .Frac) +``` + +Frac\(tion\) multiplication\. + +```clojure + ( + + + +* param subject) +``` + +### \+ + +```clojure +(-> .Frac .Frac .Frac) +``` + +Frac\(tion\) addition\. + +```clojure + ( + ++ param subject) +``` + +### \- + +```clojure +(-> .Frac .Frac .Frac) +``` + +Frac\(tion\) substraction\. + +```clojure + ( + + +- param subject) +``` + +### / + +```clojure +(-> .Frac .Frac .Frac) +``` + +Frac\(tion\) division\. + +```clojure + ( + + + + +/ param subject) +``` + +### /% + +```clojure +(-> .Frac .Frac [.Frac .Frac]) +``` + +```clojure +(/% param subject) +``` + +### < + +```clojure +(-> .Frac .Frac .Bit) +``` + +Frac\(tion\) less\-than\. + +```clojure +(< reference sample) +``` + +### <= + +```clojure +(-> .Frac .Frac .Bit) +``` + +Frac\(tion\) less\-than or equal\. + +```clojure +(<= reference sample) +``` + +### = + +```clojure +(-> .Frac .Frac .Bit) +``` + +Frac\(tion\) equivalence\. + +```clojure +(= reference sample) +``` + +### > + +```clojure +(-> .Frac .Frac .Bit) +``` + +Frac\(tion\) greater\-than\. + +```clojure +(> reference sample) +``` + +### >= + +```clojure +(-> .Frac .Frac .Bit) +``` + +Frac\(tion\) greater\-than or equal\. + +```clojure +(>= reference sample) +``` + +### abs + +```clojure +(-> .Frac .Frac) +``` + +### addition + +```clojure +(library/lux/abstract/monoid.Monoid .Frac) +``` + +### approximately? + +```clojure +(-> .Frac .Frac .Frac .Bit) +``` + +```clojure +(approximately? margin_of_error standard value) +``` + +### biggest + +```clojure +.Frac +``` + +### binary + +```clojure +(library/lux/abstract/codec.Codec .Text .Frac) +``` + +### bits + +```clojure +(-> .Frac .I64) +``` + +### decimal + +```clojure +(library/lux/abstract/codec.Codec .Text .Frac) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Frac) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash .Frac) +``` + +### hex + +```clojure +(library/lux/abstract/codec.Codec .Text .Frac) +``` + +### int + +```clojure +(-> .Frac .Int) +``` + +### max + +```clojure +(-> .Frac .Frac .Frac) +``` + +Frac\(tion\) minimum\. + +```clojure + ( + + +max left right) +``` + +### maximum + +```clojure +(library/lux/abstract/monoid.Monoid .Frac) +``` + +### min + +```clojure +(-> .Frac .Frac .Frac) +``` + +Frac\(tion\) minimum\. + +```clojure + ( + +min left right) +``` + +### minimum + +```clojure +(library/lux/abstract/monoid.Monoid .Frac) +``` + +### mod + +```clojure +(All (_ a) (-> .Frac .Frac .Frac)) +``` + +```clojure +(mod divisor dividend) +``` + +### multiplication + +```clojure +(library/lux/abstract/monoid.Monoid .Frac) +``` + +### nat + +```clojure +(-> .Frac .Nat) +``` + +### negative? + +```clojure +(library/lux/abstract/predicate.Predicate .Frac) +``` + +### negative\_infinity + +```clojure +.Frac +``` + +Negative infinity\. + +### not\_a\_number + +```clojure +.Frac +``` + +Not a number\. + +### not\_a\_number? + +```clojure +(-> .Frac .Bit) +``` + +Tests whether a frac is actually not\-a\-number\. + +```clojure +(not_a_number? it) +``` + +### number? + +```clojure +(-> .Frac .Bit) +``` + +### octal + +```clojure +(library/lux/abstract/codec.Codec .Text .Frac) +``` + +### of\_bits + +```clojure +(-> .I64 .Frac) +``` + +### opposite + +```clojure +(-> .Frac .Frac) +``` + +### order + +```clojure +(library/lux/abstract/order.Order .Frac) +``` + +### positive? + +```clojure +(library/lux/abstract/predicate.Predicate .Frac) +``` + +### positive\_infinity + +```clojure +.Frac +``` + +Positive infinity\. + +### rev + +```clojure +(-> .Frac .Rev) +``` + +### signum + +```clojure +(-> .Frac .Frac) +``` + +### smallest + +```clojure +.Frac +``` + +### zero? + +```clojure +(library/lux/abstract/predicate.Predicate .Frac) +``` + +___ + +# library/lux/math/number/i16 + +## Definitions + +### I16 + +```clojure +(Or [.Text (.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing))] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] .Nat .Nat .Nat [(.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [(.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [.Name ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)]) +``` + +A 16\-bit integer\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence (.I64 (primitive "{New Type @"library/lux/math/number/i16",13,17 0}"))) +``` + +### i16 + +```clojure +(-> .I64 (.I64 (primitive "{New Type @"library/lux/math/number/i16",13,17 0}"))) +``` + +### i64 + +```clojure +(-> (.I64 (primitive "{New Type @"library/lux/math/number/i16",13,17 0}")) .I64) +``` + +### width + +```clojure +.Nat +``` + +___ + +# library/lux/math/number/i32 + +## Definitions + +### I32 + +```clojure +(Or [.Text (.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing))] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] .Nat .Nat .Nat [(.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [(.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [.Name ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)]) +``` + +A 32\-bit integer\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence (.I64 (primitive "{New Type @"library/lux/math/number/i32",13,17 0}"))) +``` + +### i32 + +```clojure +(-> .I64 (.I64 (primitive "{New Type @"library/lux/math/number/i32",13,17 0}"))) +``` + +### i64 + +```clojure +(-> (.I64 (primitive "{New Type @"library/lux/math/number/i32",13,17 0}")) .I64) +``` + +### width + +```clojure +.Nat +``` + +___ + +# library/lux/math/number/i64 + +## Definitions + +### Mask + +```clojure +... .Type +(All (Mask a) (primitive "#I64" a)) +``` + +A pattern of bits that can be imposed on I64 values\. + +### \(Sub width\) + +```clojure +... .Type +[(library/lux/abstract/equivalence.Equivalence (.I64 width)) .Nat (-> .I64 (.I64 width)) (-> (.I64 width) .I64)] +``` + +A sub\-space of I64 with a reduce amount of bits\. + +### and + +```clojure +(All (_ a) (-> (.I64 .Any) (.I64 a) (.I64 a))) +``` + +Bitwise and\. + +```clojure + ( + + + +and parameter subject) +``` + +### bit + +```clojure +(-> .Nat Mask) +``` + +A mask with only a specific bit set\. + +```clojure +(bit position) +``` + +### bits\_per\_byte + +```clojure +.Nat +``` + +### bytes\_per\_i64 + +```clojure +.Nat +``` + +### conjunction + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (.I64 a))) +``` + +### disjunction + +```clojure +(All (_ a) (library/lux/abstract/monoid.Monoid (.I64 a))) +``` + +### equivalence + +```clojure +(All (_ a) (library/lux/abstract/equivalence.Equivalence (.I64 a))) +``` + +### false + +```clojure +Mask +``` + +### flipped + +```clojure +(All (_ a) (-> .Nat (.I64 a) (.I64 a))) +``` + +Flip bit at given index\. + +```clojure + ( + + +flipped index input) +``` + +### hash + +```clojure +(All (_ a) (library/lux/abstract/hash.Hash (.I64 a))) +``` + +### left\_rotated + +```clojure +(All (_ a) (-> .Nat (.I64 a) (.I64 a))) +``` + +```clojure + ( + +left_rotated distance input) +``` + +### left\_shifted + +```clojure +(All (_ a) (-> .Nat (.I64 a) (.I64 a))) +``` + +Bitwise left\-shift\. + +```clojure + ( + + + + + +left_shifted parameter subject) +``` + +### mask + +```clojure +(-> .Nat Mask) +``` + +Mask a block of bits of the specified size\. + +```clojure +(mask amount_of_bits) +``` + +### not + +```clojure +(All (_ a) (-> (.I64 a) (.I64 a))) +``` + +Bitwise negation\. + +### one + +```clojure +(All (_ a) (-> .Nat (.I64 a) (.I64 a))) +``` + +Set bit at given index\. + +```clojure + ( + +one index input) +``` + +### one? + +```clojure +(-> .Nat (.I64 .Any) .Bit) +``` + +```clojure +(one? index input) +``` + +### ones + +```clojure +(-> (.I64 .Any) .Nat) +``` + +Count the number of 1s in a bit\-map\. + +```clojure +(ones it) +``` + +### or + +```clojure +(All (_ a) (-> (.I64 .Any) (.I64 a) (.I64 a))) +``` + +Bitwise or\. + +```clojure + ( + +or parameter subject) +``` + +### region + +```clojure +(-> .Nat .Nat Mask) +``` + +A mask for a block of bits of the given size, starting at the given offset\. + +```clojure +(region offset size) +``` + +### reversed + +```clojure +(All (_ a) (-> (.I64 a) (.I64 a))) +``` + +### right\_rotated + +```clojure +(All (_ a) (-> .Nat (.I64 a) (.I64 a))) +``` + +```clojure + ( + + +right_rotated distance input) +``` + +### right\_shifted + +```clojure +(All (_ a) (-> .Nat (.I64 a) (.I64 a))) +``` + +Unsigned/logic bitwise right\-shift\. + +```clojure + ( + + + + + + +right_shifted parameter subject) +``` + +### sign + +```clojure +Mask +``` + +A mask for the sign bit of ints\. + +### sub + +```clojure +(Ex (_ a) (-> .Nat (.Maybe (Sub a)))) +``` + +Given a width in the interval \(0,64\), yields an implementation for integers of that width\. + +```clojure +(sub width) +``` + +### true + +```clojure +Mask +``` + +### width + +```clojure +.Nat +``` + +### xor + +```clojure +(All (_ a) (-> (.I64 .Any) (.I64 a) (.I64 a))) +``` + +Bitwise xor\. + +```clojure + ( + + +xor parameter subject) +``` + +### zero + +```clojure +(All (_ a) (-> .Nat (.I64 a) (.I64 a))) +``` + +Clear bit at the given index\. + +```clojure +(zero index input) +``` + +### zero? + +```clojure +(-> .Nat (.I64 .Any) .Bit) +``` + +```clojure +(zero? index input) +``` + +___ + +# library/lux/math/number/i8 + +## Definitions + +### I8 + +```clojure +(Or [.Text (.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing))] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] .Nat .Nat .Nat [(.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [(.List ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing) ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)] [.Name ((All (_ a) (Or [.Text (.List (? a))] [(? a) (? a)] [(? a) (? a)] [(? a) (? a)] .Nat .Nat .Nat [(.List (? a)) (? a)] [(.List (? a)) (? a)] [(? a) (? a)] [.Name (? a)])) .Nothing)]) +``` + +A 8\-bit integer\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence (.I64 (primitive "{New Type @"library/lux/math/number/i8",13,17 0}"))) +``` + +### i64 + +```clojure +(-> (.I64 (primitive "{New Type @"library/lux/math/number/i8",13,17 0}")) .I64) +``` + +### i8 + +```clojure +(-> .I64 (.I64 (primitive "{New Type @"library/lux/math/number/i8",13,17 0}"))) +``` + +### width + +```clojure +.Nat +``` + +___ + +# library/lux/math/number/int + +## Definitions + +### % + +```clojure +(-> .Int .Int .Int) +``` + +Int\(eger\) remainder\. + +```clojure + ( + + + + + +% param subject) +``` + +### \* + +```clojure +(-> .Int .Int .Int) +``` + +Int\(eger\) multiplication\. + +```clojure + ( + + + +* param subject) +``` + +### \+ + +```clojure +(-> .Int .Int .Int) +``` + +Int\(eger\) addition\. + +```clojure + ( + ++ param subject) +``` + +### \- + +```clojure +(-> .Int .Int .Int) +``` + +Int\(eger\) substraction\. + +```clojure + ( + + +- param subject) +``` + +### / + +```clojure +(-> .Int .Int .Int) +``` + +Int\(eger\) division\. + +```clojure + ( + + + + +/ param subject) +``` + +### /% + +```clojure +(-> .Int .Int [.Int .Int]) +``` + +Int\(eger\) \[division remainder\]\. + +```clojure + ( + + + + + + +/% param subject) +``` + +### < + +```clojure +(-> .Int .Int .Bit) +``` + +Int\(eger\) less\-than\. + +```clojure +(< reference sample) +``` + +### <= + +```clojure +(-> .Int .Int .Bit) +``` + +Int\(eger\) less\-than or equal\. + +```clojure +(<= reference sample) +``` + +### = + +```clojure +(-> .Int .Int .Bit) +``` + +Int\(eger\) equivalence\. + +```clojure +(= reference sample) +``` + +### > + +```clojure +(-> .Int .Int .Bit) +``` + +Int\(eger\) greater\-than\. + +```clojure +(> reference sample) +``` + +### >= + +```clojure +(-> .Int .Int .Bit) +``` + +Int\(eger\) greater\-than or equal\. + +```clojure +(>= reference sample) +``` + +### abs + +```clojure +(-> .Int .Int) +``` + +A value of equal magnitude and positive sign\. + +### addition + +```clojure +(library/lux/abstract/monoid.Monoid .Int) +``` + +### binary + +```clojure +(library/lux/abstract/codec.Codec .Text .Int) +``` + +### co\_prime? + +```clojure +(-> .Int .Int .Bit) +``` + +### decimal + +```clojure +(library/lux/abstract/codec.Codec .Text .Int) +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum .Int) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Int) +``` + +### even? + +```clojure +(-> .Int .Bit) +``` + +### extended\_gcd + +```clojure +(-> .Int .Int [[.Int .Int] .Int]) +``` + +Extended euclidean algorithm\. + +### frac + +```clojure +(-> .Int .Frac) +``` + +### gcd + +```clojure +(-> .Int .Int .Int) +``` + +Greatest Common Divisor\. + +### hash + +```clojure +(library/lux/abstract/hash.Hash .Int) +``` + +### hex + +```clojure +(library/lux/abstract/codec.Codec .Text .Int) +``` + +### interval + +```clojure +(library/lux/abstract/interval.Interval .Int) +``` + +### lcm + +```clojure +(-> .Int .Int .Int) +``` + +Least Common Multiple\. + +### max + +```clojure +(-> .Int .Int .Int) +``` + +Int\(eger\) maximum\. + +```clojure + ( + + +max left right) +``` + +### maximum + +```clojure +(library/lux/abstract/monoid.Monoid .Int) +``` + +### min + +```clojure +(-> .Int .Int .Int) +``` + +Int\(eger\) minimum\. + +```clojure + ( + +min left right) +``` + +### minimum + +```clojure +(library/lux/abstract/monoid.Monoid .Int) +``` + +### mod + +```clojure +(All (_ a) (-> .Int .Int .Int)) +``` + +Integer modulo\. +Note: The modulo and the remainder are not the same\. + +```clojure +(mod divisor dividend) +``` + +### multiplication + +```clojure +(library/lux/abstract/monoid.Monoid .Int) +``` + +### negative? + +```clojure +(library/lux/abstract/predicate.Predicate .Int) +``` + +### octal + +```clojure +(library/lux/abstract/codec.Codec .Text .Int) +``` + +### odd? + +```clojure +(-> .Int .Bit) +``` + +### opposite + +```clojure +(-> .Int .Int) +``` + +A value of equal magnitude and opposite sign\. + +### order + +```clojure +(library/lux/abstract/order.Order .Int) +``` + +### positive? + +```clojure +(library/lux/abstract/predicate.Predicate .Int) +``` + +### right\_shifted + +```clojure +(-> .Nat .Int .Int) +``` + +Signed/arithmetic bitwise right\-shift\. + +```clojure +(right_shifted parameter subject) +``` + +### signum + +```clojure +(-> .Int .Int) +``` + +A value \(either \-1, 0 or \+0\) which represents the sign\. + +### zero? + +```clojure +(library/lux/abstract/predicate.Predicate .Int) +``` + +___ + +# library/lux/math/number/nat + +## Definitions + +### % + +```clojure +(-> .Nat .Nat .Nat) +``` + +Nat\(ural\) remainder\. + +```clojure + ( + + + + + + + + + + + +% parameter subject) +``` + +### \* + +```clojure +(-> .Nat .Nat .Nat) +``` + +Nat\(ural\) multiplication\. + +```clojure + ( + + + + + + + + +* parameter subject) +``` + +### \+ + +```clojure +(-> .Nat .Nat .Nat) +``` + +Nat\(ural\) addition\. + +```clojure + ( + + ++ parameter subject) +``` + +### \- + +```clojure +(-> .Nat .Nat .Nat) +``` + +Nat\(ural\) substraction\. + +```clojure + ( + + + +- parameter subject) +``` + +### / + +```clojure +(-> .Nat .Nat .Nat) +``` + +Nat\(ural\) division\. + +```clojure + ( + + + + + + + + + +/ parameter subject) +``` + +### /% + +```clojure +(-> .Nat .Nat [.Nat .Nat]) +``` + +Nat\(ural\) \[division remainder\]\. + +```clojure + ( + + + + + + + + + + +/% parameter subject) +``` + +### < + +```clojure +(-> .Nat .Nat .Bit) +``` + +Nat\(ural\) less\-than\. + +```clojure + ( + + + + +< parameter subject) +``` + +### <= + +```clojure +(-> .Nat .Nat .Bit) +``` + +Nat\(ural\) less\-than or equal\. + +```clojure + ( + + + + + +<= parameter subject) +``` + +### = + +```clojure +(-> .Nat .Nat .Bit) +``` + +Nat\(ural\) equivalence\. + +```clojure + ( + += parameter subject) +``` + +### > + +```clojure +(-> .Nat .Nat .Bit) +``` + +Nat\(ural\) greater\-than\. + +```clojure + ( + + + + + + +> parameter subject) +``` + +### >= + +```clojure +(-> .Nat .Nat .Bit) +``` + +Nat\(ural\) greater\-than or equal\. + +```clojure + ( + + + + + + + +>= parameter subject) +``` + +### addition + +```clojure +(library/lux/abstract/monoid.Monoid .Nat) +``` + +### binary + +```clojure +(library/lux/abstract/codec.Codec .Text .Nat) +``` + +### co\_prime? + +```clojure +(-> .Nat .Nat .Bit) +``` + +### decimal + +```clojure +(library/lux/abstract/codec.Codec .Text .Nat) +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum .Nat) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Nat) +``` + +### even? + +```clojure +(-> .Nat .Bit) +``` + +### frac + +```clojure +(-> .Nat .Frac) +``` + +### gcd + +```clojure +(-> .Nat .Nat .Nat) +``` + +Greatest Common Divisor\. + +### hash + +```clojure +(library/lux/abstract/hash.Hash .Nat) +``` + +### hex + +```clojure +(library/lux/abstract/codec.Codec .Text .Nat) +``` + +### interval + +```clojure +(library/lux/abstract/interval.Interval .Nat) +``` + +### lcm + +```clojure +(-> .Nat .Nat .Nat) +``` + +Least Common Multiple\. + +### max + +```clojure +(-> .Nat .Nat .Nat) +``` + +Nat\(ural\) maximum\. + +```clojure + ( + + +max left right) +``` + +### maximum + +```clojure +(library/lux/abstract/monoid.Monoid .Nat) +``` + +### min + +```clojure +(-> .Nat .Nat .Nat) +``` + +Nat\(ural\) minimum\. + +```clojure + ( + +min left right) +``` + +### minimum + +```clojure +(library/lux/abstract/monoid.Monoid .Nat) +``` + +### multiplication + +```clojure +(library/lux/abstract/monoid.Monoid .Nat) +``` + +### octal + +```clojure +(library/lux/abstract/codec.Codec .Text .Nat) +``` + +### odd? + +```clojure +(-> .Nat .Bit) +``` + +### order + +```clojure +(library/lux/abstract/order.Order .Nat) +``` + +___ + +# library/lux/math/number/ratio + +Rational numbers\. + +## Definitions + +### % + +```clojure +(-> Ratio Ratio Ratio) +``` + +### \* + +```clojure +(-> Ratio Ratio Ratio) +``` + +### \+ + +```clojure +(-> Ratio Ratio Ratio) +``` + +### \- + +```clojure +(-> Ratio Ratio Ratio) +``` + +### / + +```clojure +(-> Ratio Ratio Ratio) +``` + +### < + +```clojure +(-> Ratio Ratio .Bit) +``` + +### <= + +```clojure +(-> Ratio Ratio .Bit) +``` + +### = + +```clojure +(-> Ratio Ratio .Bit) +``` + +### > + +```clojure +(-> Ratio Ratio .Bit) +``` + +### >= + +```clojure +(-> Ratio Ratio .Bit) +``` + +### Ratio + +```clojure +... .Type +[.Nat .Nat] +``` + +An unsigned ratio of numbers\. + +### addition + +```clojure +(library/lux/abstract/monoid.Monoid Ratio) +``` + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Ratio) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Ratio) +``` + +### multiplication + +```clojure +(library/lux/abstract/monoid.Monoid Ratio) +``` + +### nat + +```clojure +(-> Ratio (.Maybe .Nat)) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Ratio) +``` + +### ratio + +```clojure +.Macro +``` + +Rational literals\. + +```clojure +(ratio numerator denominator) + +................................................................ +................................................................ + +... The denominator can be omitted if it is 1. + +(ratio numerator) +``` + +### reciprocal + +```clojure +(-> Ratio Ratio) +``` + +___ + +# library/lux/math/number/rev + +## Definitions + +### % + +```clojure +(-> .Rev .Rev .Rev) +``` + +Rev\(olution\) remainder\. + +```clojure + ( + + + + + +% param subject) +``` + +### \* + +```clojure +(-> .Rev .Rev .Rev) +``` + +Rev\(olution\) multiplication\. + +```clojure + ( + + + +* param subject) +``` + +### \+ + +```clojure +(-> .Rev .Rev .Rev) +``` + +Rev\(olution\) addition\. + +```clojure + ( + ++ param subject) +``` + +### \- + +```clojure +(-> .Rev .Rev .Rev) +``` + +Rev\(olution\) substraction\. + +```clojure + ( + + +- param subject) +``` + +### / + +```clojure +(-> .Rev .Rev .Rev) +``` + +Rev\(olution\) division\. + +```clojure + ( + + + + +/ param subject) +``` + +### /% + +```clojure +(-> .Rev .Rev [.Rev .Rev]) +``` + +### /1 + +```clojure +.Rev +``` + +### /1024 + +```clojure +.Rev +``` + +### /128 + +```clojure +.Rev +``` + +### /16 + +```clojure +.Rev +``` + +### /2 + +```clojure +.Rev +``` + +### /2048 + +```clojure +.Rev +``` + +### /256 + +```clojure +.Rev +``` + +### /32 + +```clojure +.Rev +``` + +### /4 + +```clojure +.Rev +``` + +### /4096 + +```clojure +.Rev +``` + +### /512 + +```clojure +.Rev +``` + +### /64 + +```clojure +.Rev +``` + +### /8 + +```clojure +.Rev +``` + +### < + +```clojure +(-> .Rev .Rev .Bit) +``` + +Rev\(olution\) less\-than\. + +```clojure +(< reference sample) +``` + +### <= + +```clojure +(-> .Rev .Rev .Bit) +``` + +Rev\(olution\) less\-than or equal\. + +```clojure +(<= reference sample) +``` + +### = + +```clojure +(-> .Rev .Rev .Bit) +``` + +Rev\(olution\) equivalence\. + +```clojure +(= reference sample) +``` + +### > + +```clojure +(-> .Rev .Rev .Bit) +``` + +Rev\(olution\) greater\-than\. + +```clojure +(> reference sample) +``` + +### >= + +```clojure +(-> .Rev .Rev .Bit) +``` + +Rev\(olution\) greater\-than or equal\. + +```clojure +(>= reference sample) +``` + +### addition + +```clojure +(library/lux/abstract/monoid.Monoid .Rev) +``` + +### binary + +```clojure +(library/lux/abstract/codec.Codec .Text .Rev) +``` + +### decimal + +```clojure +(library/lux/abstract/codec.Codec .Text .Rev) +``` + +### down + +```clojure +(-> .Nat .Rev .Rev) +``` + +```clojure + ( + + +down scale subject) +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum .Rev) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Rev) +``` + +### frac + +```clojure +(-> .Rev .Frac) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash .Rev) +``` + +### hex + +```clojure +(library/lux/abstract/codec.Codec .Text .Rev) +``` + +### interval + +```clojure +(library/lux/abstract/interval.Interval .Rev) +``` + +### max + +```clojure +(-> .Rev .Rev .Rev) +``` + +Rev\(olution\) maximum\. + +```clojure + ( + + +max left right) +``` + +### maximum + +```clojure +(library/lux/abstract/monoid.Monoid .Rev) +``` + +### min + +```clojure +(-> .Rev .Rev .Rev) +``` + +Rev\(olution\) minimum\. + +```clojure + ( + +min left right) +``` + +### minimum + +```clojure +(library/lux/abstract/monoid.Monoid .Rev) +``` + +### octal + +```clojure +(library/lux/abstract/codec.Codec .Text .Rev) +``` + +### order + +```clojure +(library/lux/abstract/order.Order .Rev) +``` + +### ratio + +```clojure +(-> .Rev .Rev .Nat) +``` + +Ratio between two rev\(olution\)s\. + +```clojure + ( + + + + + + +ratio param subject) +``` + +### reciprocal + +```clojure +(-> .Nat .Rev) +``` + +Rev\(olution\) reciprocal of a Nat\(ural\)\. + +```clojure +(reciprocal numerator) +``` + +### up + +```clojure +(-> .Nat .Rev .Rev) +``` + +```clojure + ( + +up scale subject) +``` + +___ + +# library/lux/math/random + +Pseudo\-random number generation \(PRNG\) algorithms\. + +## Definitions + +### PRNG + +```clojure +... .Type +((All (PRNG a) (-> .Any [(PRNG .Nothing) .I64])) .Nothing) +``` + +An abstract way to represent any PRNG\. + +### \(Random it\) + +```clojure +... .Type +(-> PRNG [PRNG it]) +``` + +A producer of random values based on a PRNG\. + +### and + +```clojure +(All (_ a b) (-> (Random a) (Random b) (Random [a b]))) +``` + +Sequencing combinator\. + +```clojure +(and left right) +``` + +### apply + +```clojure +(library/lux/abstract/apply.Apply Random) +``` + +### array + +```clojure +(All (_ a) (-> .Nat (Random a) (Random (library/lux/data/collection/array.Array a)))) +``` + +### ascii + +```clojure +(-> .Nat (Random .Text)) +``` + +### ascii/alpha + +```clojure +(-> .Nat (Random .Text)) +``` + +### ascii/alpha\_num + +```clojure +(-> .Nat (Random .Text)) +``` + +### ascii/lower + +```clojure +(-> .Nat (Random .Text)) +``` + +### ascii/numeric + +```clojure +(-> .Nat (Random .Text)) +``` + +### ascii/upper + +```clojure +(-> .Nat (Random .Text)) +``` + +### bit + +```clojure +(Random .Bit) +``` + +### char + +```clojure +(-> library/lux/data/text/unicode/set.Set (Random library/lux/data/text.Char)) +``` + +### complex + +```clojure +(Random library/lux/math/number/complex.Complex) +``` + +### date + +```clojure +(Random library/lux/time/date.Date) +``` + +### day + +```clojure +(Random library/lux/time/day.Day) +``` + +### dictionary + +```clojure +(All (_ a b) (-> (library/lux/abstract/hash.Hash a) .Nat (Random a) (Random b) (Random (library/lux/data/collection/dictionary.Dictionary a b)))) +``` + +```clojure +(dictionary hash size key_gen value_gen) +``` + +### duration + +```clojure +(Random library/lux/time/duration.Duration) +``` + +### either + +```clojure +(All (_ a) (-> (Random a) (Random a) (Random a))) +``` + +Homogeneous alternative combinator\. + +```clojure +(either left right) +``` + +### frac + +```clojure +(Random .Frac) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor Random) +``` + +### i64 + +```clojure +(Random .I64) +``` + +### instant + +```clojure +(Random library/lux/time/instant.Instant) +``` + +### int + +```clojure +(Random .Int) +``` + +### list + +```clojure +(All (_ a) (-> .Nat (Random a) (Random (.List a)))) +``` + +### maybe + +```clojure +(All (_ a) (-> (Random a) (Random (.Maybe a)))) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Random) +``` + +### month + +```clojure +(Random library/lux/time/month.Month) +``` + +### nat + +```clojure +(Random .Nat) +``` + +### one + +```clojure +(All (_ a b) (-> (-> a (.Maybe b)) (Random a) (Random b))) +``` + +```clojure +(one check random) +``` + +### only + +```clojure +(All (_ a) (-> (-> a .Bit) (Random a) (Random a))) +``` + +Retries the generator until the output satisfies a predicate\. + +```clojure +(only pred gen) +``` + +### or + +```clojure +(All (_ a b) (-> (Random a) (Random b) (Random (Or a b)))) +``` + +Heterogeneous alternative combinator\. + +```clojure +(or left right) +``` + +### pcg\_32 + +```clojure +(-> [(.I64 .Any) (.I64 .Any)] PRNG) +``` + +An implementation of the PCG32 algorithm\. +For more information, please see: http://www\.pcg\-random\.org/ + +### prng + +```clojure +(All (_ a) (-> (-> a a) (-> a .I64) a PRNG)) +``` + +```clojure +(prng update return) +``` + +### queue + +```clojure +(All (_ a) (-> .Nat (Random a) (Random (library/lux/data/collection/queue.Queue a)))) +``` + +### ratio + +```clojure +(Random library/lux/math/number/ratio.Ratio) +``` + +### rec + +```clojure +(All (_ a) (-> (-> (Random a) (Random a)) (Random a))) +``` + +A combinator for producing recursive random generators\. + +```clojure +(rec gen) +``` + +### refined + +```clojure +(All (_ a b) (-> (library/lux/type/refinement.Refiner a b) (Random a) (Random (library/lux/type/refinement.Refined a b)))) +``` + +Retries the generator until the output can be refined\. + +```clojure +(refined refiner gen) +``` + +### result + +```clojure +(All (_ a) (-> PRNG (Random a) [PRNG a])) +``` + +```clojure +(result prng calc) +``` + +### rev + +```clojure +(Random .Rev) +``` + +### row + +```clojure +(All (_ a) (-> .Nat (Random a) (Random (library/lux/data/collection/row.Row a)))) +``` + +### safe\_frac + +```clojure +(Random .Frac) +``` + +A number in the interval \[0\.0,1\.0\]\. + +### set + +```clojure +(All (_ a) (-> (library/lux/abstract/hash.Hash a) .Nat (Random a) (Random (library/lux/data/collection/set.Set a)))) +``` + +```clojure +(set hash size value_gen) +``` + +### split\_mix\_64 + +```clojure +(-> .Nat PRNG) +``` + +An implementation of the SplitMix64 algorithm\. + +### stack + +```clojure +(All (_ a) (-> .Nat (Random a) (Random (library/lux/data/collection/stack.Stack a)))) +``` + +### text + +```clojure +(-> (Random library/lux/data/text.Char) .Nat (Random .Text)) +``` + +```clojure +(text char_gen size) +``` + +### time + +```clojure +(Random library/lux/time.Time) +``` + +### unicode + +```clojure +(-> .Nat (Random .Text)) +``` + +### xoroshiro\_128\+ + +```clojure +(-> [(.I64 .Any) (.I64 .Any)] PRNG) +``` + +An implementation of the Xoroshiro128\+ algorithm\. +For more information, please see: http://xoroshiro\.di\.unimi\.it/ + +___ + +# library/lux/meta + +Functions for extracting information from the state of the compiler\. + +## Definitions + +### apply + +```clojure +(library/lux/abstract/apply.Apply .Meta) +``` + +### assertion + +```clojure +(-> .Text .Bit (.Meta .Any)) +``` + +Fails with the given message if the test is \#0\. + +```clojure +(assertion message test) +``` + +### compiler\_state + +```clojure +(.Meta .Lux) +``` + +Obtains the current state of the compiler\. + +### current\_module + +```clojure +(.Meta .Module) +``` + +The module currently being compiled, if any\. + +### current\_module\_name + +```clojure +(.Meta .Text) +``` + +The name of the module currently being compiled, if any\. + +### de\_aliased + +```clojure +(-> .Name (.Meta .Name)) +``` + +Given an aliased definition's name, returns the original definition being referenced\. + +```clojure +(de_aliased def_name) +``` + +### definition + +```clojure +(-> .Name (.Meta .Global)) +``` + +Looks\-up a definition's whole data in the available modules \(including the current one\)\. + +```clojure +(definition name) +``` + +### definition\_type + +```clojure +(-> .Name (.Meta .Type)) +``` + +Looks\-up a definition's type in the available modules \(including the current one\)\. + +```clojure +(definition_type name) +``` + +### definitions + +```clojure +(-> .Text (.Meta (.List [.Text .Definition]))) +``` + +The entire list of definitions in a module \(including the non\-exported/private ones\)\. + +```clojure +(definitions module) +``` + +### either + +```clojure +(All (_ a) (-> (.Meta a) (.Meta a) (.Meta a))) +``` + +Pick whichever computation succeeds\. + +```clojure +(either left right) +``` + +### eval + +```clojure +(-> .Type .Code (.Meta .Any)) +``` + +```clojure +(eval type code) +``` + +### expected\_type + +```clojure +(.Meta .Type) +``` + +The expected type of the current expression being analyzed\. + +### export + +```clojure +(-> .Name (.Meta .Definition)) +``` + +Looks\-up a definition in the available modules \(including the current one\)\. +The look\-up only succeeds if the definition has been exported\. + +```clojure +(export name) +``` + +### exports + +```clojure +(-> .Text (.Meta (.List [.Text .Definition]))) +``` + +All the exported definitions in a module\. + +```clojure +(exports module_name) +``` + +### failure + +```clojure +(All (_ a) (-> .Text (.Meta a))) +``` + +Fails with the given error message\. + +```clojure +(failure error) +``` + +### functor + +```clojure +(library/lux/abstract/functor.Functor .Meta) +``` + +### globals + +```clojure +(-> .Text (.Meta (.List [.Text .Global]))) +``` + +The entire list of globals in a module \(including the non\-exported/private ones\)\. + +```clojure +(globals module) +``` + +### imported? + +```clojure +(-> .Text (.Meta .Bit)) +``` + +Checks if the given module has been imported by the current module\. + +```clojure +(imported? import) +``` + +### imported\_by? + +```clojure +(-> .Text .Text (.Meta .Bit)) +``` + +```clojure +(imported_by? import module) +``` + +### imported\_modules + +```clojure +(-> .Text (.Meta (.List .Text))) +``` + +All the modules imported by a specified module\. + +```clojure +(imported_modules module_name) +``` + +### lifted + +```clojure +(All (_ a) (-> (library/lux/control/try.Try a) (.Meta a))) +``` + +### locals + +```clojure +(.Meta (.List (.List [.Text .Type]))) +``` + +All the local variables currently in scope, separated in different scopes\. + +### location + +```clojure +(.Meta .Location) +``` + +The location of the current expression being analyzed\. + +### macro + +```clojure +(-> .Name (.Meta (.Maybe .Macro))) +``` + +Looks\-up a macro known by the given name\. + +```clojure +(macro full_name) +``` + +### module + +```clojure +(-> .Text (.Meta .Module)) +``` + +Looks\-up a module with the given name\. + +```clojure +(module name) +``` + +### module\_exists? + +```clojure +(-> .Text (.Meta .Bit)) +``` + +```clojure +(module_exists? module) +``` + +### modules + +```clojure +(.Meta (.List [.Text .Module])) +``` + +All the available modules \(including the current one\)\. + +### monad + +```clojure +(library/lux/abstract/monad.Monad .Meta) +``` + +### normal + +```clojure +(-> .Name (.Meta .Name)) +``` + +If given a name without a module prefix, gives it the current module's name as prefix\. +Otherwise, returns the name as\-is\. + +```clojure +(normal name) +``` + +### result + +```clojure +(All (_ a) (-> .Lux (.Meta a) (library/lux/control/try.Try a))) +``` + +Evaluates a computation that depends on Lux's compiler state\. + +```clojure +(result lux action) +``` + +### result' + +```clojure +(All (_ a) (-> .Lux (.Meta a) (library/lux/control/try.Try [.Lux a]))) +``` + +Evaluates a computation that depends on Lux's compiler state\. +Also returns a \(potentially modified\) compiler state\. + +```clojure +(result' lux action) +``` + +### seed + +```clojure +(.Meta .Nat) +``` + +The current value of a number tracked by the compiler\. +Also increases the value, so it's different next time it is seen\. +This number can be used for generating data 'randomly' during compilation\. + +### tag + +```clojure +(-> .Name (.Meta [.Nat (.List .Name) .Type])) +``` + +Given a tag, finds out what is its index, its related tag\-list and its associated type\. + +```clojure +(tag tag_name) +``` + +### tag\_lists + +```clojure +(-> .Text (.Meta (.List [(.List .Name) .Type]))) +``` + +All the tag\-lists defined in a module, with their associated types\. + +```clojure +(tag_lists module) +``` + +### tags\_of + +```clojure +(-> .Name (.Meta (.Maybe (.List .Name)))) +``` + +All the tags associated with a type definition\. + +```clojure +(tags_of type_name) +``` + +### type + +```clojure +(-> .Name (.Meta .Type)) +``` + +Looks\-up the type of either a local variable or a definition\. + +```clojure +(type name) +``` + +### type\_context + +```clojure +(.Meta .Type_Context) +``` + +The current type\-checking context\. + +### type\_definition + +```clojure +(-> .Name (.Meta .Type)) +``` + +Finds the value of a type definition \(such as Int, Any or Lux\)\. + +```clojure +(type_definition name) +``` + +### var\_type + +```clojure +(-> .Text (.Meta .Type)) +``` + +Looks\-up the type of a local variable somewhere in the environment\. + +```clojure +(var_type name) +``` + +___ + +# library/lux/meta/annotation + +Machinary for querying annotations on modules and definitions\. + +## Definitions + +### Annotation + +```clojure +... .Type +(.Ann .Location (.Code' (.Ann .Location))) +``` + +### bit + +```clojure +(-> .Name Annotation (.Maybe .Bit)) +``` + +```clojure + ( + + +bit tag ann) +``` + +### documentation + +```clojure +(-> Annotation (.Maybe .Text)) +``` + +### flagged? + +```clojure +(-> .Name Annotation .Bit) +``` + +### form + +```clojure +(-> .Name Annotation (.Maybe (.List .Code))) +``` + +```clojure + ( + + + + + + + + + + +form tag ann) +``` + +### frac + +```clojure +(-> .Name Annotation (.Maybe .Frac)) +``` + +```clojure + ( + + + + + + +frac tag ann) +``` + +### function\_arguments + +```clojure +(-> Annotation (.List .Text)) +``` + +### identifier + +```clojure +(-> .Name Annotation (.Maybe .Name)) +``` + +```clojure + ( + + + + + + + + +identifier tag ann) +``` + +### implementation? + +```clojure +(-> Annotation .Bit) +``` + +### int + +```clojure +(-> .Name Annotation (.Maybe .Int)) +``` + +```clojure + ( + + + + +int tag ann) +``` + +### nat + +```clojure +(-> .Name Annotation (.Maybe .Nat)) +``` + +```clojure + ( + + + +nat tag ann) +``` + +### record + +```clojure +(-> .Name Annotation (.Maybe (.List [.Code .Code]))) +``` + +```clojure + ( + + + + + + + + + + + + +record tag ann) +``` + +### rev + +```clojure +(-> .Name Annotation (.Maybe .Rev)) +``` + +```clojure + ( + + + + + +rev tag ann) +``` + +### tag + +```clojure +(-> .Name Annotation (.Maybe .Name)) +``` + +```clojure + ( + + + + + + + + + +tag tag ann) +``` + +### text + +```clojure +(-> .Name Annotation (.Maybe .Text)) +``` + +```clojure + ( + + + + + + + +text tag ann) +``` + +### tuple + +```clojure +(-> .Name Annotation (.Maybe (.List .Code))) +``` + +```clojure + ( + + + + + + + + + + + +tuple tag ann) +``` + +### type\_arguments + +```clojure +(-> Annotation (.List .Text)) +``` + +### value + +```clojure +(-> .Name Annotation (.Maybe .Code)) +``` + +```clojure + ( + +value tag ann) +``` + +___ + +# library/lux/meta/location + +## Definitions + +### dummy + +```clojure +.Location +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Location) +``` + +### format + +```clojure +(-> .Location .Text) +``` + +### here + +```clojure +.Macro +``` + +The Location of the current form\. + +```clojure +(here) +``` + +### with + +```clojure +(-> .Location .Text .Text) +``` + +```clojure +(with location error) +``` + +___ + +# library/lux/program + +## Definitions + +### program: + +```clojure +.Macro +``` + +Defines the entry\-point to a program \(similar to the 'main' function/method in other programming languages\)\. + +```clojure +... Can take a list of all the input parameters to the program. + +(program: all_arguments + (do library/lux/control/io.monad + [foo (initialize program)] + (do_something_with all_arguments))) + +................................................................ +................................................................ + +... Can also parse them using CLI parsers from the library/lux/control/parser/cli module. + +(program: [config configuration_parser] + (do library/lux/control/io.monad + [data (initialize program with config)] + (do_something_with data))) +``` + +___ + +# library/lux/static + +## Definitions + +### frac + +```clojure +.Macro +``` + +```clojure + ( + + + + + + +frac (: + + + + + + .Frac (value generating expression))) +``` + +### int + +```clojure +.Macro +``` + +```clojure + ( + + + + +int (: + + + + .Int (value generating expression))) +``` + +### literal + +```clojure +.Macro +``` + +```clojure +(literal + (: (-> ??? Code) + format) + (: ??? + (value generating expression))) +``` + +### nat + +```clojure +.Macro +``` + +```clojure + ( + + + +nat (: + + + .Nat (value generating expression))) +``` + +### random + +```clojure +.Macro +``` + +```clojure +(random + (: (-> ??? Code) + format) + (: (Random ???) + (random data generator))) +``` + +### random\_frac + +```clojure +.Macro +``` + +```clojure + (: + + + + + + .Frac ( + + + + +random_frac)) +``` + +### random\_int + +```clojure +.Macro +``` + +```clojure + (: + + + + .Int ( + + +random_int)) +``` + +### random\_nat + +```clojure +.Macro +``` + +```clojure + (: + + + .Nat ( + +random_nat)) +``` + +### random\_rev + +```clojure +.Macro +``` + +```clojure + (: + + + + + .Rev ( + + + +random_rev)) +``` + +### rev + +```clojure +.Macro +``` + +```clojure + ( + + + + + +rev (: + + + + + .Rev (value generating expression))) +``` + +### text + +```clojure +.Macro +``` + +```clojure + ( + + + + + + + +text (: + + + + + + + .Text (value generating expression))) +``` + +___ + +# library/lux/target + +## Definitions + +### Target + +```clojure +... .Type +(primitive "#Text") +``` + +The name/ID of a platform targetted by a Lux compiler\. +This information can be used to generate code targetting specific platforms, and to make programs cross\-platform\. + +### common\_lisp + +```clojure +Target +``` + +### js + +```clojure +Target +``` + +### jvm + +```clojure +Target +``` + +### lua + +```clojure +Target +``` + +### old + +```clojure +Target +``` + +### php + +```clojure +Target +``` + +### python + +```clojure +Target +``` + +### r + +```clojure +Target +``` + +### ruby + +```clojure +Target +``` + +### scheme + +```clojure +Target +``` + +___ + +# library/lux/test + +Tools for unit & property\-based/generative testing\. + +## Definitions + +### Assertion + +```clojure +... .Type +(library/lux/control/concurrency/async.Async [Tally .Text]) +``` + +An asynchronous operation that yields test results\. + +### Seed + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +The seed value used for random testing \(if that feature is used\)\. + +### Tally + +```clojure +... .Type +[.Nat .Nat (library/lux/data/collection/set.Set .Name) (library/lux/data/collection/set.Set .Name)] +``` + +A record of successes and failures while executing tests\. + +### Test + +```clojure +... .Type +(library/lux/math/random.Random Assertion) +``` + +A test that relies on random data generation to thoroughly cover different scenarios\. + +### and + +```clojure +(-> Test Test Test) +``` + +Sequencing combinator\. + +```clojure +(and left right) +``` + +### and' + +```clojure +(-> Assertion Assertion Assertion) +``` + +Sequencing combinator \(for assertions\)\. + +```clojure +(and' left right) +``` + +### assertion + +```clojure +(-> .Text .Bit Assertion) +``` + +Check that a condition is \#1, and fail with the given message otherwise\. + +```clojure +(assertion message condition) +``` + +### context + +```clojure +(-> .Text Test Test) +``` + +Adds a contextual description to a test's documentation\. + +```clojure +(context description) +``` + +### cover + +```clojure +.Macro +``` + +Specifies a test as covering one or more definitions\. +Adds to the test tally information to track which definitions have been tested\. + +```clojure + ( + + + + +cover [definition/0 definition/1 ,,, definition/N] + (: Bit + (some "computation"))) +``` + +### cover' + +```clojure +.Macro +``` + +Specifies a test as covering one or more definitions\. +Adds to the test tally information to track which definitions have been tested\. + +```clojure + ( + + + +cover' [definition/0 definition/1 ,,, definition/N] + (: Bit + (some "computation"))) +``` + +### covering + +```clojure +.Macro +``` + +Specifies the module being covered by a test\. +Adds tracking information to the tally to know which exported definitions in the module need to be covered\. + +```clojure +(covering documentation/lux/test._ + (: Test + some_test)) +``` + +### error\_during\_execution + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### failure + +```clojure +(-> .Text Test) +``` + +A failing test, with a given error message\. + +### for + +```clojure +.Macro +``` + +Specifies a context for tests as covering one or more definitions\. +Adds to the test tally information to track which definitions have been tested\. + +```clojure +(for [definition/0 definition/1 ,,, definition/N] + (: Test + some_test)) +``` + +### in\_parallel + +```clojure +(-> (.List Test) Test) +``` + +Executes multiple tests in parallel \(if the host platform supports it\) to take advantage of multiple cores\. + +```clojure +(in_parallel tests) +``` + +### lifted + +```clojure +(-> .Text (library/lux/math/random.Random .Bit) Test) +``` + +```clojure +(lifted message random) +``` + +### must\_try\_test\_at\_least\_once + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### run\! + +```clojure +(-> Test (library/lux/control/concurrency/async.Async .Nothing)) +``` + +Executes a test, and exits the program with either a successful or a failing exit code\. +WARNING: This procedure is only meant to be used in \(program: \.\.\.\) forms\. + +```clojure +(run! test) +``` + +### seed + +```clojure +(-> Seed Test Test) +``` + +Execute the given test with a specific seed value\. +This allows you to reproduce a failing test case as many times as you want while debugging\. + +```clojure +(seed value test) +``` + +### test + +```clojure +(-> .Text .Bit Test) +``` + +Check that a condition is \#1, and fail with the given message otherwise\. + +```clojure +(test message condition) +``` + +### times + +```clojure +(-> .Nat Test Test) +``` + +Allows executing a test several times\. +By doing this, it's possible to thoroughly test code with many different scenarios\. +This assumes that random data generation is being used in tests instead of fixed/constant inputs\. + +```clojure +(times amount test) +``` + +___ + +# library/lux/time + +## Definitions + +### Clock + +```clojure +... .Type +[.Nat .Nat .Nat .Nat] +``` + +A clock marking the specific hour, minute, second, and milli\-second in a day\. + +### Time + +```clojure +... .Type +(primitive "library/lux/time.Time") +``` + +Time is defined as milliseconds since the start of the day \(00:00:00\.000\)\. + +### clock + +```clojure +(-> Time Clock) +``` + +```clojure +(clock time) +``` + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Time) +``` + +Based on ISO 8601\. +For example: 21:14:51\.827 + +### enum + +```clojure +(library/lux/abstract/enum.Enum Time) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Time) +``` + +### hours + +```clojure +.Nat +``` + +Number of hours in an day\. + +### invalid\_hour + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### invalid\_minute + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### invalid\_second + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### midnight + +```clojure +Time +``` + +The instant corresponding to the start of the day: 00:00:00\.000 + +### milli\_seconds + +```clojure +.Nat +``` + +Number of milli\-seconds in a second\. + +### millis + +```clojure +(-> Time .Nat) +``` + +### minutes + +```clojure +.Nat +``` + +Number of minutes in an hour\. + +### of\_millis + +```clojure +(-> .Nat (library/lux/control/try.Try Time)) +``` + +```clojure +(of_millis milli_seconds) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Time) +``` + +### parser + +```clojure +(library/lux/control/parser/text.Parser Time) +``` + +### seconds + +```clojure +.Nat +``` + +Number of seconds in a minute\. + +### time + +```clojure +(-> Clock (library/lux/control/try.Try Time)) +``` + +```clojure +(time clock) +``` + +### time\_exceeds\_a\_day + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +___ + +# library/lux/time/date + +## Definitions + +### Date + +```clojure +... .Type +(primitive "library/lux/time/date.Date") +``` + +A date specified as a year/month/day triplet\. + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Date) +``` + +Based on ISO 8601\. +For example: 2017\-01\-15 + +### date + +```clojure +(-> library/lux/time/year.Year library/lux/time/month.Month .Nat (library/lux/control/try.Try Date)) +``` + +A date, within the allowed limits\. + +```clojure +(date year month day_of_month) +``` + +### day\_of\_month + +```clojure +(-> Date .Nat) +``` + +### days + +```clojure +(-> Date .Int) +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum Date) +``` + +### epoch + +```clojure +Date +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Date) +``` + +### invalid\_day + +```clojure +(library/lux/control/exception.Exception [library/lux/time/year.Year library/lux/time/month.Month .Nat]) +``` + +### invalid\_month + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### month + +```clojure +(-> Date library/lux/time/month.Month) +``` + +### of\_days + +```clojure +(-> .Int Date) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Date) +``` + +### parser + +```clojure +(library/lux/control/parser/text.Parser Date) +``` + +### year + +```clojure +(-> Date library/lux/time/year.Year) +``` + +___ + +# library/lux/time/day + +## Definitions + +### Day + +```clojure +... .Type +(Or .Any .Any .Any .Any .Any .Any .Any) +``` + +A day of the week\. + +### by\_number + +```clojure +(-> .Nat (library/lux/control/try.Try Day)) +``` + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Day) +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum Day) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Day) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash Day) +``` + +### invalid\_day + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### not\_a\_day\_of\_the\_week + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### number + +```clojure +(-> Day .Nat) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Day) +``` + +### week + +```clojure +(.List Day) +``` + +All the days, ordered by when they come in a week\. + +___ + +# library/lux/time/duration + +## Definitions + +### Duration + +```clojure +... .Type +(primitive "library/lux/time/duration.Duration") +``` + +Durations have a resolution of milli\-seconds\. + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Duration) +``` + +### day + +```clojure +Duration +``` + +### difference + +```clojure +(-> Duration Duration Duration) +``` + +```clojure +(difference from to) +``` + +### down + +```clojure +(-> .Nat Duration Duration) +``` + +### empty + +```clojure +Duration +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum Duration) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Duration) +``` + +### framed + +```clojure +(-> Duration Duration Duration) +``` + +### hour + +```clojure +Duration +``` + +### inverse + +```clojure +(-> Duration Duration) +``` + +### leap\_year + +```clojure +Duration +``` + +### merged + +```clojure +(-> Duration Duration Duration) +``` + +### milli\_second + +```clojure +Duration +``` + +### millis + +```clojure +(-> Duration .Int) +``` + +### minute + +```clojure +Duration +``` + +### monoid + +```clojure +(library/lux/abstract/monoid.Monoid Duration) +``` + +### negative? + +```clojure +(-> Duration .Bit) +``` + +### neutral? + +```clojure +(-> Duration .Bit) +``` + +### normal\_year + +```clojure +Duration +``` + +### of\_millis + +```clojure +(-> .Int Duration) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Duration) +``` + +### positive? + +```clojure +(-> Duration .Bit) +``` + +### second + +```clojure +Duration +``` + +### ticks + +```clojure +(-> Duration Duration .Int) +``` + +### up + +```clojure +(-> .Nat Duration Duration) +``` + +### week + +```clojure +Duration +``` + +___ + +# library/lux/time/instant + +## Definitions + +### Instant + +```clojure +... .Type +(primitive "library/lux/time/instant.Instant") +``` + +Instant is defined as milli\-seconds since the epoch\. + +### absolute + +```clojure +(-> library/lux/time/duration.Duration Instant) +``` + +```clojure +(absolute offset) +``` + +### after + +```clojure +(-> library/lux/time/duration.Duration Instant Instant) +``` + +```clojure +(after duration instant) +``` + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Instant) +``` + +Based on ISO 8601\. +For example: 2017\-01\-15T21:14:51\.827Z + +### date + +```clojure +(-> Instant library/lux/time/date.Date) +``` + +### day\_of\_week + +```clojure +(-> Instant library/lux/time/day.Day) +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum Instant) +``` + +### epoch + +```clojure +Instant +``` + +The instant corresponding to 1970\-01\-01T00:00:00Z\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Instant) +``` + +### millis + +```clojure +(-> Instant .Int) +``` + +### now + +```clojure +(library/lux/control/io.IO Instant) +``` + +Yields the current instant, as measured from the operating\-system's clock\. + +### of\_date\_time + +```clojure +(-> library/lux/time/date.Date library/lux/time.Time Instant) +``` + +```clojure +(of_date_time date time) +``` + +### of\_millis + +```clojure +(-> .Int Instant) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Instant) +``` + +### relative + +```clojure +(-> Instant library/lux/time/duration.Duration) +``` + +```clojure +(relative instant) +``` + +### span + +```clojure +(-> Instant Instant library/lux/time/duration.Duration) +``` + +```clojure +(span from to) +``` + +### time + +```clojure +(-> Instant library/lux/time.Time) +``` + +___ + +# library/lux/time/month + +## Definitions + +### Month + +```clojure +... .Type +(Or .Any .Any .Any .Any .Any .Any .Any .Any .Any .Any .Any .Any) +``` + +A month of the year\. + +### by\_number + +```clojure +(-> .Nat (library/lux/control/try.Try Month)) +``` + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Month) +``` + +### days + +```clojure +(-> Month .Nat) +``` + +The amount of days of a month\. + +```clojure +(days month) +``` + +### enum + +```clojure +(library/lux/abstract/enum.Enum Month) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Month) +``` + +### hash + +```clojure +(library/lux/abstract/hash.Hash Month) +``` + +### invalid\_month + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### leap\_year\_days + +```clojure +(-> Month .Nat) +``` + +The amount of days of a month \(in a leap year\)\. + +```clojure +(leap_year_days month) +``` + +### not\_a\_month\_of\_the\_year + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +### number + +```clojure +(-> Month .Nat) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Month) +``` + +### year + +```clojure +(.List Month) +``` + +All the months, ordered by when they come in a year\. + +___ + +# library/lux/time/year + +## Definitions + +### Period + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +An amount of years\. + +### Year + +```clojure +... .Type +(primitive "library/lux/time/year.Year") +``` + +A year in the gregorian calendar\. +Both negative \(< 0\) and positive \(> 0\) values are valid, but not 0\. +This is because the first year of the gregorian calendar was year 1\. + +### century + +```clojure +Period +``` + +### codec + +```clojure +(library/lux/abstract/codec.Codec .Text Year) +``` + +Based on ISO 8601\. +For example: 2017 + +### days + +```clojure +.Nat +``` + +The amount of days in a typical year\. + +### epoch + +```clojure +Year +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Year) +``` + +### era + +```clojure +Period +``` + +### leap + +```clojure +Period +``` + +### leap? + +```clojure +(-> Year .Bit) +``` + +### leaps + +```clojure +(-> Year .Int) +``` + +The number of leap years in a period of years\. + +```clojure +(leaps year) +``` + +### order + +```clojure +(library/lux/abstract/order.Order Year) +``` + +### parser + +```clojure +(library/lux/control/parser/text.Parser Year) +``` + +### there\_is\_no\_year\_0 + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### value + +```clojure +(-> Year .Int) +``` + +### year + +```clojure +(-> .Int (library/lux/control/try.Try Year)) +``` + +A valid year in the gregorian calendar, if possible\. + +```clojure +(year value) +``` + +___ + +# library/lux/type + +Basic functionality for working with types\. + +## Definitions + +### :as + +```clojure +.Macro +``` + +Casts a value to a specific type\. +The specified type can depend on type variables of the original type of the value\. +NOTE: Careless use of type\-casts is an easy way to introduce bugs\. USE WITH CAUTION\. + +```clojure +(: (Bar Bit Nat Text) + (:as [a b c] + (Foo a [b c]) + (Bar a b c) + (: (Foo Bit [Nat Text]) + (foo expression)))) +``` + +### :by\_example + +```clojure +.Macro +``` + +Constructs a type that shares type\-variables with an expression of some other type\. + +```clojure +(: Type + (:by_example [a b c] + (Foo a [b c]) + (: (Foo Bit [Nat Text]) + (foo expression)) + + (Bar a b c))) + +... => + +(.type(Bar Bit Nat Text)) +``` + +### :log\! + +```clojure +.Macro +``` + +Logs to the console/terminal the type of an expression\. + +```clojure +(:log! (: Foo (foo expression))) + +... => + +... Expression: (foo expression) + +... Type: Foo + +(foo expression) +``` + +### :sharing + +```clojure +.Macro +``` + +Allows specifing the type of an expression as sharing type\-variables with the type of another expression\. + +```clojure +(: (Bar Bit Nat Text) + (:sharing [a b c] + (Foo a [b c]) + (: (Foo Bit [Nat Text]) + (foo expression)) + + (Bar a b c) + (bar expression))) +``` + +### anonymous + +```clojure +(-> .Type .Type) +``` + +A type without any names covering it\. + +```clojure +(anonymous type) +``` + +### application + +```clojure +(-> (.List .Type) .Type .Type) +``` + +An un\-evaluated type application, with the given quantified type, and parameters\. + +```clojure +(application params quant) +``` + +### applied + +```clojure +(-> (.List .Type) .Type (.Maybe .Type)) +``` + +To the extend possible, applies a quantified type to the given parameters\. + +```clojure +(applied params func) +``` + +### array + +```clojure +(-> .Nat .Type .Type) +``` + +An array type, with the given level of nesting/depth, and the given element type\. + +```clojure +(array depth element_type) +``` + +### array? + +```clojure +(-> .Type .Bit) +``` + +Is a type an array type? + +### code + +```clojure +(-> .Type .Code) +``` + +A representation of a type as code\. +The code is such that evaluating it would yield the type value\. + +```clojure +(code type) +``` + +### de\_aliased + +```clojure +(-> .Type .Type) +``` + +A \(potentially named\) type that does not have its name shadowed by other names\. + +```clojure +(de_aliased type) +``` + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence .Type) +``` + +### ex\_q + +```clojure +(-> .Nat .Type .Type) +``` + +A quantified type, with the given number of parameters, and body\. + +```clojure + ( + + +ex_q size body) +``` + +### flat\_application + +```clojure +(-> .Type [.Type (.List .Type)]) +``` + +The quantified type, and its parameters, for a type\-application\. + +```clojure +(flat_application type) +``` + +### flat\_array + +```clojure +(-> .Type [.Nat .Type]) +``` + +The level of nesting/depth and element type for an array type\. + +```clojure +(flat_array type) +``` + +### flat\_ex\_q + +```clojure +(-> .Type [.Nat .Type]) +``` + +The number of parameters, and the body, of a quantified type\. + +```clojure + ( + + +flat_ex_q type) +``` + +### flat\_function + +```clojure +(-> .Type [(.List .Type) .Type]) +``` + +The input, and the output of a function type\. + +```clojure +(flat_function type) +``` + +### flat\_tuple + +```clojure +(-> .Type (.List .Type)) +``` + +The members of a composite type\. + +```clojure + ( + + +flat_tuple type) +``` + +### flat\_univ\_q + +```clojure +(-> .Type [.Nat .Type]) +``` + +The number of parameters, and the body, of a quantified type\. + +```clojure + ( + +flat_univ_q type) +``` + +### flat\_variant + +```clojure +(-> .Type (.List .Type)) +``` + +The members of a composite type\. + +```clojure + ( + +flat_variant type) +``` + +### format + +```clojure +(-> .Type .Text) +``` + +A \(readable\) textual representable of a type\. + +```clojure +(format type) +``` + +### function + +```clojure +(-> (.List .Type) .Type .Type) +``` + +A function type, with the given inputs and output\. + +```clojure +(function inputs output) +``` + +### quantified? + +```clojure +(-> .Type .Bit) +``` + +Only yields \#1 for universally or existentially quantified types\. + +```clojure +(quantified? type) +``` + +### tuple + +```clojure +(-> (.List .Type) .Type) +``` + +A composite type, constituted by the given member types\. + +```clojure + ( + + +tuple types) +``` + +### univ\_q + +```clojure +(-> .Nat .Type .Type) +``` + +A quantified type, with the given number of parameters, and body\. + +```clojure + ( + +univ_q size body) +``` + +### variant + +```clojure +(-> (.List .Type) .Type) +``` + +A composite type, constituted by the given member types\. + +```clojure + ( + +variant types) +``` + +___ + +# library/lux/type/abstract + +## Definitions + +### :abstraction + +```clojure +.Macro +``` + +Type\-casting macro for abstract/nominal types\. + +```clojure + (: + + + abstraction ( + +:abstraction (: + + representation value))) +``` + +### :representation + +```clojure +.Macro +``` + +Type\-casting macro for abstract/nominal types\. + +```clojure + (: + + + + representation ( + + +:representation (: + + + abstraction value))) +``` + +### :transmutation + +```clojure +.Macro +``` + +Transmutes an abstract/nominal type's phantom types\. + +```clojure +(abstract: (JavaScript a) + {} + + Text + + (abstract: Expression {} Any) + (abstract: Statement {} Any) + + (def: (statement expression) + (-> (JavaScript Expression) (JavaScript Statement)) + (:transmutation expression)) + + (def: (statement' expression) + (-> (JavaScript Expression) (JavaScript Statement)) + (:transmutation JavaScript expression))) +``` + +### Frame + +```clojure +... .Type +[.Text (.List .Code) .Code .Code] +``` + +Meta\-data about an abstract/nominal type in a stack of them\. + +### ^:representation + +```clojure +.Macro +``` + +Pattern\-matching macro to easily extract a representation\. + +```clojure +(def: (computation abstraction) + (All (_ a) (-> (Abstract a) ???)) + (let [(^:representation value) abstraction] + (foo (bar (baz value))))) +``` + +### abstract: + +```clojure +.Macro +``` + +Define abstract/nominal types which hide their representation details\. +You can convert between the abstraction and its representation selectively to access the value, while hiding it from others\. + +```clojure +(abstract: String + {} + + Text + + (def: (string value) + (-> Text String) + (:abstraction value)) + + (def: (text value) + (-> String Text) + (:representation value))) + +................................................................ +................................................................ + +... Type-parameters are optional. + +(abstract: (Duplicate a) + {} + + [a a] + + (def: (duplicate value) + (All (_ a) (-> a (Duplicate a))) + (:abstraction [value value]))) + +................................................................ +................................................................ + +... Definitions can be nested. + +(abstract: (Single a) + {} + + a + + (def: (single value) + (All (_ a) (-> a (Single a))) + (:abstraction value)) + + (abstract: (Double a) + {} + + [a a] + + (def: (double value) + (All (_ a) (-> a (Double a))) + (:abstraction [value value])) + + (def: (single' value) + (All (_ a) (-> a (Single a))) + (:abstraction Single [value value])) + + (let [value 123] + (same? value + (|> value + single' + (:representation Single) + double + :representation))))) + +................................................................ +................................................................ + +... Type-parameters do not necessarily have to be used in the representation type. + +... If they are not used, they become phantom types and can be used to customize types without changing the representation. + +(abstract: (JavaScript a) + {} + + Text + + (abstract: Expression {} Any) + (abstract: Statement {} Any) + + (def: (+ x y) + (-> (JavaScript Expression) (JavaScript Expression) (JavaScript Expression)) + (:abstraction + (format "(" (:representation x) "+" (:representation y) ")"))) + + (def: (while test body) + (-> (JavaScript Expression) (JavaScript Statement) (JavaScript Statement)) + (:abstraction + (format "while(" (:representation test) ") {" + (:representation body) + "}")))) +``` + +### current + +```clojure +(.Meta Frame) +``` + +The currently\-being\-defined abstract/nominal type\. + +### no\_active\_frames + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### specific + +```clojure +(-> .Text (.Meta Frame)) +``` + +A specific abstract/nominal type still being defined somewhere in the scope\. + +```clojure +(specific name) +``` + +___ + +# library/lux/type/check + +Type\-checking functionality\. + +## Definitions + +### \(Check it\) + +```clojure +... .Type +(-> .Type_Context (library/lux/control/try.Try [.Type_Context it])) +``` + +A type\-checking computation which may fail or yield a value\. + +### Var + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +The ID for a type\-variable in a type\-checking context\. + +### apply + +```clojure +(library/lux/abstract/apply.Apply Check) +``` + +### assertion + +```clojure +(-> .Text .Bit (Check .Any)) +``` + +```clojure +(assertion message test) +``` + +### bind + +```clojure +(-> .Type Var (Check .Any)) +``` + +Attemmpts to buy a type\-variable\. +Fails if the variable has been bound already\. + +```clojure +(bind type id) +``` + +### bound? + +```clojure +(-> Var (Check .Bit)) +``` + +### cannot\_rebind\_var + +```clojure +(library/lux/control/exception.Exception [.Nat .Type .Type]) +``` + +### check + +```clojure +(-> .Type .Type (Check .Any)) +``` + +Type\-check to ensure that the 'expected' type subsumes the 'actual' type\. + +```clojure +(check expected actual) +``` + +### clean + +```clojure +(-> .Type (Check .Type)) +``` + +Resolves every bound type\-variable to yield a new type that is as resolved as possible\. + +```clojure +(clean inputT) +``` + +### context + +```clojure +(Check .Type_Context) +``` + +The current state of the type\-checking context\. + +### except + +```clojure +(All (_ a b) (-> (library/lux/control/exception.Exception a) a (Check b))) +``` + +```clojure +(except exception message) +``` + +### existential + +```clojure +(Check [.Nat .Type]) +``` + +A brand\-new existential type\. + +### failure + +```clojure +(All (_ a) (-> .Text (Check a))) +``` + +```clojure +(failure message) +``` + +### fresh\_context + +```clojure +.Type_Context +``` + +An empty/un\-used type\-checking context\. + +### functor + +```clojure +(library/lux/abstract/functor.Functor Check) +``` + +### invalid\_type\_application + +```clojure +(library/lux/control/exception.Exception [.Type .Type]) +``` + +### monad + +```clojure +(library/lux/abstract/monad.Monad Check) +``` + +### peek + +```clojure +(-> Var (Check (.Maybe .Type))) +``` + +### read + +```clojure +(-> Var (Check .Type)) +``` + +### result + +```clojure +(All (_ a) (-> .Type_Context (Check a) (library/lux/control/try.Try a))) +``` + +```clojure +(result context proc) +``` + +### subsumes? + +```clojure +(-> .Type .Type .Bit) +``` + +A simple type\-checking function that just returns a yes/no answer\. + +```clojure +(subsumes? expected actual) +``` + +### type\_check\_failed + +```clojure +(library/lux/control/exception.Exception [.Type .Type]) +``` + +### unbound\_type\_var + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### unknown\_type\_var + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### var + +```clojure +(Check [Var .Type]) +``` + +A brand\-new \(unbound\) type\-variable\. + +___ + +# library/lux/type/dynamic + +## Definitions + +### :dynamic + +```clojure +.Macro +``` + +```clojure +(: Dynamic + (:dynamic 123)) +``` + +### :static + +```clojure +.Macro +``` + +```clojure +(: (try.Try Nat) + (:static Nat (:dynamic 123))) +``` + +### Dynamic + +```clojure +... .Type +(primitive "library/lux/type/dynamic.Dynamic") +``` + +A value coupled with its type, so it can be checked later\. + +### format + +```clojure +(-> Dynamic (library/lux/control/try.Try .Text)) +``` + +### wrong\_type + +```clojure +(library/lux/control/exception.Exception [.Type .Type]) +``` + +___ + +# library/lux/type/implicit + +## Definitions + +### \\\\ + +```clojure +.Macro +``` + +Automatic implementation selection \(for type\-class style polymorphism\)\. +This feature layers type\-class style polymorphism on top of Lux's signatures and implementations\. +When calling a polymorphic function, or using a polymorphic constant, +this macro will check the types of the arguments, and the expected type for the whole expression +and it will search in the local scope, the module's scope and the imports' scope +in order to find suitable implementations to satisfy those requirements\. +If a single alternative is found, that one will be used automatically\. +If no alternative is found, or if more than one alternative is found \(ambiguity\) +a compile\-time error will be raised, to alert the user\. + +Caveat emptor: You need to make sure to import the module of any implementation you want to use\. +Otherwise, this macro will not find it\. + +```clojure +... Nat equivalence + +(\ number.equivalence = x y) + +(\\ = x y) + +................................................................ +................................................................ + +... Can optionally add the prefix of the module where the signature was defined. + +(\\ equivalence.= x y) + +................................................................ +................................................................ + +... (List Nat) equivalence + +(\\ = + (list.indices 10) + (list.indices 10)) + +................................................................ +................................................................ + +... (Functor List) each + +(\\ each ++ (list.indices 10)) +``` + +### implicit: + +```clojure +.Macro +``` + +Establish local definitions for implementations that will be prioritized over foreign definitions\. + +```clojure +(implicit: [n.multiplication]) + +(n.= (\ n.multiplication composite left right) + (\\ composite left right)) +``` + +### with + +```clojure +.Macro +``` + +Establish lexical bindings for implementations that will be prioritized over non\-lexically\-bound implementations\. + +```clojure +(with [n.addition] + (n.= (\ n.addition composite left right) + (\\ composite left right))) +``` + +___ + +# library/lux/type/poly + +## Definitions + +### code + +```clojure +(-> library/lux/control/parser/type.Env .Type .Code) +``` + +```clojure +(code env type) +``` + +### derived: + +```clojure +.Macro +``` + +```clojure +(type: Variant + (.Variant + (#Bit Bit) + (#Text Text) + (#Frac Frac))) + +(type: Recursive + (Rec Recursive + (.Variant + (#Number Frac) + (#Addition Frac Recursive)))) + +(type: Record + (.Record + {#bit Bit + #frac Frac + #text Text + #maybe (Maybe Frac) + #list (List Frac) + #dictionary (Dictionary Text Frac) + #variant Variant + #tuple [Bit Text Frac] + #recursive Recursive + #date Date + #grams (Qty Gram)})) + +(derived: equivalence + (specification/lux/abstract/equivalence.equivalence + Record)) + +(: (Equivalence Record) + equivalence) + +(derived: codec + (specification/lux/abstract/codec.codec + Record)) + +(: (Codec Json Record) + codec) +``` + +### poly: + +```clojure +.Macro +``` + +___ + +# library/lux/type/quotient + +## Definitions + +### \(Class value label\) + +```clojure +... .Type +(All (_ c) (primitive "library/lux/type/quotient.Class" value label c)) +``` + +The class knows how to classify/label values that are meant to be equivalent to one another\. + +### \(Quotient value label\) + +```clojure +... .Type +(All (_ c) (primitive "library/lux/type/quotient.Quotient" value label c)) +``` + +A quotient value has been labeled with a class\. +All equivalent values will belong to the same class\. +This means all equivalent values possess the same label\. + +### class + +```clojure +(All (_ a b) (Ex (_ c) (-> (-> a b) (Class a b c)))) +``` + +### equivalence + +```clojure +(All (_ a b c) (-> (library/lux/abstract/equivalence.Equivalence b) (library/lux/abstract/equivalence.Equivalence (Quotient a b c)))) +``` + +### label + +```clojure +(All (_ a b c) (-> (Quotient a b c) b)) +``` + +### quotient + +```clojure +(All (_ a b c) (-> (Class a b c) a (Quotient a b c))) +``` + +```clojure +(quotient class value) +``` + +### type + +```clojure +.Macro +``` + +The Quotient type associated with a Class type\. + +```clojure +(def: even + (class even?)) + +(def: Even + Type + (type even)) + +(: Even + (quotient even 123)) +``` + +### value + +```clojure +(All (_ a b c) (-> (Quotient a b c) a)) +``` + +___ + +# library/lux/type/refinement + +## Definitions + +### \(Refined it\) + +```clojure +... .Type +(All (_ b) (primitive "library/lux/type/refinement.Refined" it b)) +``` + +A refined version of another type, using a predicate to select valid instances\. + +### \(Refiner it\) + +```clojure +... .Type +(All (_ b) (-> it (.Maybe (Refined it b)))) +``` + +A selection mechanism for refined instances of a type\. + +### lifted + +```clojure +(All (_ a b) (-> (-> a a) (Refined a b) (.Maybe (Refined a b)))) +``` + +Yields a function that can work on refined values\. +Respects the constraints of the refinement\. + +```clojure +(lifted transform) +``` + +### only + +```clojure +(All (_ a b) (-> (Refiner a b) (.List a) (.List (Refined a b)))) +``` + +```clojure +(only refiner values) +``` + +### partition + +```clojure +(All (_ a b) (-> (Refiner a b) (.List a) [(.List (Refined a b)) (.List a)])) +``` + +Separates refined values from the un\-refined ones\. + +```clojure +(partition refiner values) +``` + +### predicate + +```clojure +(All (_ a b) (-> (Refined a b) (library/lux/abstract/predicate.Predicate a))) +``` + +### refiner + +```clojure +(All (_ a) (Ex (_ b) (-> (library/lux/abstract/predicate.Predicate a) (Refiner a b)))) +``` + +```clojure +(refiner predicate) +``` + +### type + +```clojure +.Macro +``` + +The Refined type associated with a Refiner type\. + +```clojure +(def: even + (refiner even?)) + +(def: Even + Type + (type even)) + +(: (Maybe Even) + (even 123)) +``` + +### value + +```clojure +(All (_ a b) (-> (Refined a b) a)) +``` + +___ + +# library/lux/type/resource + +## Definitions + +### \(Affine monad permissions value\) + +```clojure +... .Type +(All (_ d) (Procedure monad d [permissions d] value)) +``` + +A procedure which expands the number of available resources\. + +### Commutative + +```clojure +... .Type +(primitive "library/lux/type/resource.Commutative") +``` + +The mode of keys which CAN be swapped, and for whom order of release/consumption DOES NOT matters\. + +### \(Key mode key\) + +```clojure +... .Type +(primitive "library/lux/type/resource.Key" mode key) +``` + +The access right for a resource\. +Without the key for a resource existing somewhere among the available ambient rights, one cannot use a resource\. + +### \(Linear monad value\) + +```clojure +... .Type +(All (_ c) (Procedure monad c c value)) +``` + +A procedure that is constant with regards to resource access rights\. +This means no additional resources will be available after the computation is over\. +This also means no previously available resources will have been consumed\. + +### Ordered + +```clojure +... .Type +(primitive "library/lux/type/resource.Ordered") +``` + +The mode of keys which CANNOT be swapped, and for whom order of release/consumption matters\. + +### \(Procedure monad input output value\) + +```clojure +... .Type +(-> input (monad [output value])) +``` + +A computation that takes a sequence of resource access rights as inputs and yields a different sequence as outputs\. +A procedure yields a result value\. +A procedure can make use of monadic effects\. + +### \(Relevant monad permissions value\) + +```clojure +... .Type +(All (_ d) (Procedure monad [permissions d] d value)) +``` + +A procedure which reduces the number of available resources\. + +### \(Res key value\) + +```clojure +... .Type +(primitive "library/lux/type/resource.Res" key value) +``` + +A resource locked by a key\. +The 'key' represents the right to access/consume a resource\. + +### amount\_cannot\_be\_zero + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### commutative + +```clojure +(All (_ a b) (Ex (_ c) (-> (library/lux/abstract/monad.Monad a) b (Affine a (Key Commutative c) (Res c b))))) +``` + +Makes a value into a resource and adds the key/access\-right to it to the ambient keyring for future use\. + +```clojure + ( + + +commutative monad value) +``` + +### exchange + +```clojure +.Macro +``` + +A function that can exchange the keys for resource, so long as they are commutative\. +This keys will be placed at the front of the keyring in the order they are specified\. +The specific keys must be specified based of their index into the current keyring\. + +```clojure +(do (monad !) + [res|left (commutative ! pre) + res|right (commutative ! post) + _ ((exchange [1 0]) !) + left (read ! res|left) + right (read ! res|right)] + (in (format left right))) +``` + +### group + +```clojure +.Macro +``` + +Group/un\-group keys in the keyring into/out\-of tuples\. + +```clojure +(do (monad !) + [res|left (commutative ! pre) + res|right (commutative ! post) + _ ((group 2) !) + _ ((un_group 2) !) + right (read ! res|right) + left (read ! res|left)] + (in (format left right))) +``` + +### index\_cannot\_be\_repeated + +```clojure +(library/lux/control/exception.Exception .Nat) +``` + +### lifted + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (a b) (Linear a b))) +``` + +```clojure +(lifted monad procedure) +``` + +### monad + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (library/lux/abstract/monad/indexed.IxMonad (Procedure a)))) +``` + +### ordered + +```clojure +(All (_ a b) (Ex (_ c) (-> (library/lux/abstract/monad.Monad a) b (Affine a (Key Ordered c) (Res c b))))) +``` + +Makes a value into a resource and adds the key/access\-right to it to the ambient keyring for future use\. + +```clojure + ( + +ordered monad value) +``` + +### read + +```clojure +(All (_ a b c d) (-> (library/lux/abstract/monad.Monad a) (Res c b) (Relevant a (Key d c) b))) +``` + +Access the value of a resource, so long as its key is available\. + +```clojure +(read monad resource) +``` + +### run\! + +```clojure +(All (_ a b) (-> (library/lux/abstract/monad.Monad a) (Linear a b) (a b))) +``` + +```clojure +(run! monad procedure) +``` + +### un\_group + +```clojure +.Macro +``` + +Group/un\-group keys in the keyring into/out\-of tuples\. + +```clojure +(do (monad !) + [res|left (commutative ! pre) + res|right (commutative ! post) + _ ((group 2) !) + _ ((un_group 2) !) + right (read ! res|right) + left (read ! res|left)] + (in (format left right))) +``` + +___ + +# library/lux/type/unit + +## Definitions + +### \* + +```clojure +(All (_ a b) (-> (Qty a) (Qty b) (Qty [a b]))) +``` + +```clojure + ( + + + +* param subject) +``` + +### \+ + +```clojure +(All (_ a) (-> (Qty a) (Qty a) (Qty a))) +``` + +```clojure + ( + ++ param subject) +``` + +### \- + +```clojure +(All (_ a) (-> (Qty a) (Qty a) (Qty a))) +``` + +```clojure + ( + + +- param subject) +``` + +### / + +```clojure +(All (_ a b) (-> (Qty a) (Qty [a b]) (Qty b))) +``` + +```clojure + ( + + + + +/ param subject) +``` + +### Giga + +```clojure +... .Type +(All (Giga a) (primitive "library/lux/type/unit.Giga" a)) +``` + +### Gram + +```clojure +... .Type +(primitive "library/lux/type/unit.Gram") +``` + +### Kilo + +```clojure +... .Type +(All (Kilo a) (primitive "library/lux/type/unit.Kilo" a)) +``` + +### Litre + +```clojure +... .Type +(primitive "library/lux/type/unit.Litre") +``` + +### Mega + +```clojure +... .Type +(All (Mega a) (primitive "library/lux/type/unit.Mega" a)) +``` + +### Meter + +```clojure +... .Type +(primitive "library/lux/type/unit.Meter") +``` + +### Micro + +```clojure +... .Type +(All (Micro a) (primitive "library/lux/type/unit.Micro" a)) +``` + +### Milli + +```clojure +... .Type +(All (Milli a) (primitive "library/lux/type/unit.Milli" a)) +``` + +### Nano + +```clojure +... .Type +(All (Nano a) (primitive "library/lux/type/unit.Nano" a)) +``` + +### Pure + +```clojure +... .Type +(Qty .Any) +``` + +A pure, unit\-less quantity\. + +### \(Qty unit\) + +```clojure +... .Type +(primitive "library/lux/type/unit.Qty" unit) +``` + +A quantity with an associated unit of measurement\. + +### \(Scale scale\) + +```clojure +... .Type +[(All (_ b) (-> (Qty b) (Qty (scale b)))) (All (_ b) (-> (Qty (scale b)) (Qty b))) library/lux/math/number/ratio.Ratio] +``` + +A scale of magnitude\. + +### Second + +```clojure +... .Type +(primitive "library/lux/type/unit.Second") +``` + +### \(Unit unit\) + +```clojure +... .Type +[(-> .Int (Qty unit)) (-> (Qty unit) .Int)] +``` + +A unit of measurement, to qualify numbers with\. + +### enum + +```clojure +(All (_ a) (library/lux/abstract/enum.Enum (Qty a))) +``` + +### equivalence + +```clojure +(All (_ a) (library/lux/abstract/equivalence.Equivalence (Qty a))) +``` + +### giga + +```clojure +(Scale Giga) +``` + +The 'giga' scale, from 1 to 1000000000\. + +### gram + +```clojure +(Unit Gram) +``` + +The 'gram' unit of meaurement\. + +### kilo + +```clojure +(Scale Kilo) +``` + +The 'kilo' scale, from 1 to 1000\. + +### litre + +```clojure +(Unit Litre) +``` + +The 'litre' unit of meaurement\. + +### mega + +```clojure +(Scale Mega) +``` + +The 'mega' scale, from 1 to 1000000\. + +### meter + +```clojure +(Unit Meter) +``` + +The 'meter' unit of meaurement\. + +### micro + +```clojure +(Scale Micro) +``` + +The 'micro' scale, from 1000000 to 1\. + +### milli + +```clojure +(Scale Milli) +``` + +The 'milli' scale, from 1000 to 1\. + +### nano + +```clojure +(Scale Nano) +``` + +The 'nano' scale, from 1000000000 to 1\. + +### number + +```clojure +(-> Pure .Int) +``` + +### order + +```clojure +(All (_ a) (library/lux/abstract/order.Order (Qty a))) +``` + +### pure + +```clojure +(-> .Int Pure) +``` + +### re\_scaled + +```clojure +(All (_ a b c) (-> (Scale a) (Scale b) (Qty (a c)) (Qty (b c)))) +``` + +```clojure +(re_scaled from to quantity) +``` + +### scale: + +```clojure +.Macro +``` + +Define a scale of magnitude\. + +```clojure +(scale: .publicBajillion bajillion + [1 1234567890]) +``` + +### second + +```clojure +(Unit Second) +``` + +The 'second' unit of meaurement\. + +### unit: + +```clojure +.Macro +``` + +Define a unit of measurement\. +Both the name of the type, and the name of the Unit implementation must be specified\. + +```clojure +(unit: .publicFeet feet) +``` + +___ + +# library/lux/type/variance + +## Definitions + +### \(Co it\) + +```clojure +... .Type +(-> .Any it) +``` + +A constraint for covariant types\. + +### \(Contra it\) + +```clojure +... .Type +(-> it .Any) +``` + +A constraint for contravariant types\. + +### \(In it\) + +```clojure +... .Type +(-> it it) +``` + +A constraint for invariant types\. + +___ + +# library/lux/world/console + +## Definitions + +### \(Console \!\) + +```clojure +... .Type +[(-> .Any (! (library/lux/control/try.Try library/lux/data/text.Char))) (-> .Any (! (library/lux/control/try.Try .Text))) (-> .Text (! (library/lux/control/try.Try .Any))) (-> .Any (! (library/lux/control/try.Try .Any)))] +``` + +An interface to console/terminal I/O\. + +### \(Mock s\) + +```clojure +... .Type +[(-> s (library/lux/control/try.Try [s library/lux/data/text.Char])) (-> s (library/lux/control/try.Try [s .Text])) (-> .Text s (library/lux/control/try.Try s)) (-> s (library/lux/control/try.Try s))] +``` + +A mock/simulation of a console\. +Useful for testing\. + +### async + +```clojure +(-> (Console library/lux/control/io.IO) (Console library/lux/control/concurrency/async.Async)) +``` + +### cannot\_close + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### cannot\_open + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### default + +```clojure +(library/lux/control/io.IO (library/lux/control/try.Try (Console library/lux/control/io.IO))) +``` + +### mock + +```clojure +(All (_ a) (-> (Mock a) a (Console library/lux/control/io.IO))) +``` + +```clojure +(mock mock init) +``` + +### write\_line + +```clojure +(All (_ a) (-> .Text (Console a) (a (library/lux/control/try.Try .Any)))) +``` + +Writes the message on the console and appends a new\-line/line\-feed at the end\. + +```clojure +(write_line message console) +``` + +___ + +# library/lux/world/file + +## Definitions + +### Path + +```clojure +... .Type +(primitive "#Text") +``` + +A path to a file or a directory in a file\-system\. + +### \(System \!\) + +```clojure +... .Type +[.Text (-> Path (! .Bit)) (-> Path (! .Bit)) (-> Path (! (library/lux/control/try.Try .Any))) (-> Path (! (library/lux/control/try.Try (.List Path)))) (-> Path (! (library/lux/control/try.Try (.List Path)))) (-> Path (! (library/lux/control/try.Try .Nat))) (-> Path (! (library/lux/control/try.Try library/lux/time/instant.Instant))) (-> Path (! (library/lux/control/try.Try .Bit))) (-> Path (! (library/lux/control/try.Try library/lux/data/binary.Binary))) (-> Path (! (library/lux/control/try.Try .Any))) (-> library/lux/time/instant.Instant Path (! (library/lux/control/try.Try .Any))) (-> library/lux/data/binary.Binary Path (! (library/lux/control/try.Try .Any))) (-> library/lux/data/binary.Binary Path (! (library/lux/control/try.Try .Any))) (-> Path Path (! (library/lux/control/try.Try .Any)))] +``` + +An interface to a file\-system\. + +### async + +```clojure +(-> (System library/lux/control/io.IO) (System library/lux/control/concurrency/async.Async)) +``` + +### cannot\_delete + +```clojure +(library/lux/control/exception.Exception Path) +``` + +### cannot\_find\_directory + +```clojure +(library/lux/control/exception.Exception Path) +``` + +### cannot\_find\_file + +```clojure +(library/lux/control/exception.Exception Path) +``` + +### cannot\_make\_directory + +```clojure +(library/lux/control/exception.Exception Path) +``` + +### cannot\_make\_file + +```clojure +(library/lux/control/exception.Exception Path) +``` + +### cannot\_modify\_file + +```clojure +(library/lux/control/exception.Exception [library/lux/time/instant.Instant Path]) +``` + +### cannot\_read\_all\_data + +```clojure +(library/lux/control/exception.Exception Path) +``` + +### default + +```clojure +(System library/lux/control/io.IO) +``` + +### exists? + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (System a) Path (a .Bit))) +``` + +Checks if either a file or a directory exists at the given path\. + +```clojure +(exists? monad fs path) +``` + +### make\_directories + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (System a) Path (a (library/lux/control/try.Try .Any)))) +``` + +Creates the directory specified by the given path\. +Also, creates every super\-directory necessary to make the given path valid\. + +```clojure +(make_directories monad fs path) +``` + +### make\_file + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (System a) library/lux/data/binary.Binary Path (a (library/lux/control/try.Try .Any)))) +``` + +Creates a new file with the given content if\-and\-only\-if the file does not already exist\. + +```clojure +(make_file monad fs content path) +``` + +### mock + +```clojure +(-> .Text (System library/lux/control/concurrency/async.Async)) +``` + +A purely in\-memory simulation of a file\-system\. +Useful for testing\. + +```clojure +(mock separator) +``` + +### name + +```clojure +(All (_ a) (-> (System a) Path .Text)) +``` + +The un\-nested name of a file/directory\. + +```clojure +(name fs path) +``` + +### parent + +```clojure +(All (_ a) (-> (System a) Path (.Maybe Path))) +``` + +If a path represents a nested file/directory, extracts its parent directory\. + +```clojure +(parent fs path) +``` + +### rooted + +```clojure +(All (_ a) (-> (System a) Path .Text Path)) +``` + +A nested path for a file/directory, given a root/parent path and a file/directory name within it\. + +```clojure +(rooted fs parent child) +``` + +___ + +# library/lux/world/file/watch + +## Definitions + +### Concern + +```clojure +... .Type +(primitive "library/lux/world/file/watch.Concern") +``` + +A particular concern to watch\-out for\. + +### \(Watcher \!\) + +```clojure +... .Type +[(-> Concern library/lux/world/file.Path (! (library/lux/control/try.Try .Any))) (-> library/lux/world/file.Path (! (library/lux/control/try.Try Concern))) (-> library/lux/world/file.Path (! (library/lux/control/try.Try Concern))) (-> .Any (! (library/lux/control/try.Try (.List [Concern library/lux/world/file.Path]))))] +``` + +Machinery for watching a file\-system for changes to files and directories\. + +### all + +```clojure +Concern +``` + +### also + +```clojure +(-> Concern Concern Concern) +``` + +```clojure +(also left right) +``` + +### cannot\_poll\_a\_non\_existent\_directory + +```clojure +(library/lux/control/exception.Exception library/lux/world/file.Path) +``` + +### creation + +```clojure +Concern +``` + +### creation? + +```clojure +(library/lux/abstract/predicate.Predicate Concern) +``` + +### default + +```clojure +(library/lux/control/io.IO (library/lux/control/try.Try (Watcher library/lux/control/concurrency/async.Async))) +``` + +The default watcher for the default file\-system\. + +### deletion + +```clojure +Concern +``` + +### deletion? + +```clojure +(library/lux/abstract/predicate.Predicate Concern) +``` + +### mock + +```clojure +(-> .Text [(library/lux/world/file.System library/lux/control/concurrency/async.Async) (Watcher library/lux/control/concurrency/async.Async)]) +``` + +A fake/emulated watcher\. +Must be given a path separator for the file\-system\. + +```clojure +(mock separator) +``` + +### modification + +```clojure +Concern +``` + +### modification? + +```clojure +(library/lux/abstract/predicate.Predicate Concern) +``` + +### not\_being\_watched + +```clojure +(library/lux/control/exception.Exception library/lux/world/file.Path) +``` + +### polling + +```clojure +(-> (library/lux/world/file.System library/lux/control/concurrency/async.Async) (Watcher library/lux/control/concurrency/async.Async)) +``` + +A simple watcher that works for any file\-system\.Polls files and directories to detect changes\. + +```clojure +(polling fs) +``` + +___ + +# library/lux/world/input/keyboard + +## Definitions + +### Key + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +A key from a keyboard, identify by a numeric ID\. + +### Press + +```clojure +... .Type +[.Bit Key] +``` + +A key\-press for a key\. + +### a + +```clojure +Key +``` + +### alt + +```clojure +Key +``` + +### b + +```clojure +Key +``` + +### back\_space + +```clojure +Key +``` + +### c + +```clojure +Key +``` + +### caps\_lock + +```clojure +Key +``` + +### control + +```clojure +Key +``` + +### d + +```clojure +Key +``` + +### delete + +```clojure +Key +``` + +### down + +```clojure +Key +``` + +### e + +```clojure +Key +``` + +### end + +```clojure +Key +``` + +### enter + +```clojure +Key +``` + +### escape + +```clojure +Key +``` + +### f + +```clojure +Key +``` + +### f1 + +```clojure +Key +``` + +### f10 + +```clojure +Key +``` + +### f11 + +```clojure +Key +``` + +### f12 + +```clojure +Key +``` + +### f13 + +```clojure +Key +``` + +### f14 + +```clojure +Key +``` + +### f15 + +```clojure +Key +``` + +### f16 + +```clojure +Key +``` + +### f17 + +```clojure +Key +``` + +### f18 + +```clojure +Key +``` + +### f19 + +```clojure +Key +``` + +### f2 + +```clojure +Key +``` + +### f20 + +```clojure +Key +``` + +### f21 + +```clojure +Key +``` + +### f22 + +```clojure +Key +``` + +### f23 + +```clojure +Key +``` + +### f24 + +```clojure +Key +``` + +### f3 + +```clojure +Key +``` + +### f4 + +```clojure +Key +``` + +### f5 + +```clojure +Key +``` + +### f6 + +```clojure +Key +``` + +### f7 + +```clojure +Key +``` + +### f8 + +```clojure +Key +``` + +### f9 + +```clojure +Key +``` + +### g + +```clojure +Key +``` + +### h + +```clojure +Key +``` + +### home + +```clojure +Key +``` + +### i + +```clojure +Key +``` + +### insert + +```clojure +Key +``` + +### j + +```clojure +Key +``` + +### k + +```clojure +Key +``` + +### l + +```clojure +Key +``` + +### left + +```clojure +Key +``` + +### m + +```clojure +Key +``` + +### n + +```clojure +Key +``` + +### num\_lock + +```clojure +Key +``` + +### num\_pad\_0 + +```clojure +Key +``` + +### num\_pad\_1 + +```clojure +Key +``` + +### num\_pad\_2 + +```clojure +Key +``` + +### num\_pad\_3 + +```clojure +Key +``` + +### num\_pad\_4 + +```clojure +Key +``` + +### num\_pad\_5 + +```clojure +Key +``` + +### num\_pad\_6 + +```clojure +Key +``` + +### num\_pad\_7 + +```clojure +Key +``` + +### num\_pad\_8 + +```clojure +Key +``` + +### num\_pad\_9 + +```clojure +Key +``` + +### o + +```clojure +Key +``` + +### p + +```clojure +Key +``` + +### page\_down + +```clojure +Key +``` + +### page\_up + +```clojure +Key +``` + +### press + +```clojure +(-> Key Press) +``` + +### print\_screen + +```clojure +Key +``` + +### q + +```clojure +Key +``` + +### r + +```clojure +Key +``` + +### release + +```clojure +(-> Key Press) +``` + +### right + +```clojure +Key +``` + +### s + +```clojure +Key +``` + +### scroll\_lock + +```clojure +Key +``` + +### shift + +```clojure +Key +``` + +### space + +```clojure +Key +``` + +### t + +```clojure +Key +``` + +### u + +```clojure +Key +``` + +### up + +```clojure +Key +``` + +### v + +```clojure +Key +``` + +### w + +```clojure +Key +``` + +### windows + +```clojure +Key +``` + +### x + +```clojure +Key +``` + +### y + +```clojure +Key +``` + +### z + +```clojure +Key +``` + +___ + +# library/lux/world/net + +## Definitions + +### Address + +```clojure +... .Type +(primitive "#Text") +``` + +A TCP/IP address\. + +### Location + +```clojure +... .Type +[Address Port] +``` + +### Port + +```clojure +... .Type +(primitive "#I64" (primitive "#Nat")) +``` + +A TCP/IP port\. + +### URL + +```clojure +... .Type +(primitive "#Text") +``` + +A Uniform Resource Locator\. + +___ + +# library/lux/world/net/http/client + +## Definitions + +### \(Client \!\) + +```clojure +... .Type +(-> library/lux/world/net/http.Method library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (! (library/lux/control/try.Try (library/lux/world/net/http.Response !)))) +``` + +A HTTP client capable of issuing requests to a HTTP server\. + +### async + +```clojure +(-> (Client library/lux/control/io.IO) (Client library/lux/control/concurrency/async.Async)) +``` + +A ASYNC request\. + +### connect + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A CONNECT request\. + +### default + +```clojure +(Client library/lux/control/io.IO) +``` + +A DEFAULT request\. + +### delete + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A DELETE request\. + +### get + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A GET request\. + +### head + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A HEAD request\. + +### headers + +```clojure +(-> (.List [.Text .Text]) library/lux/world/net/http.Headers) +``` + +A HEADERS request\. + +### options + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A OPTIONS request\. + +### patch + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A PATCH request\. + +### post + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A POST request\. + +### put + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A PUT request\. + +### trace + +```clojure +(All (_ a) (-> library/lux/world/net.URL library/lux/world/net/http.Headers (.Maybe library/lux/data/binary.Binary) (Client a) (a (library/lux/control/try.Try (library/lux/world/net/http.Response a))))) +``` + +A TRACE request\. + +___ + +# library/lux/world/net/http/status + +## Definitions + +### accepted + +```clojure +library/lux/world/net/http.Status +``` + +202: ACCEPTED + +### already\_reported + +```clojure +library/lux/world/net/http.Status +``` + +208: ALREADY REPORTED + +### bad\_gateway + +```clojure +library/lux/world/net/http.Status +``` + +502: BAD GATEWAY + +### bad\_request + +```clojure +library/lux/world/net/http.Status +``` + +400: BAD REQUEST + +### conflict + +```clojure +library/lux/world/net/http.Status +``` + +409: CONFLICT + +### continue + +```clojure +library/lux/world/net/http.Status +``` + +100: CONTINUE + +### created + +```clojure +library/lux/world/net/http.Status +``` + +201: CREATED + +### early\_hints + +```clojure +library/lux/world/net/http.Status +``` + +103: EARLY HINTS + +### expectation\_failed + +```clojure +library/lux/world/net/http.Status +``` + +417: EXPECTATION FAILED + +### failed\_dependency + +```clojure +library/lux/world/net/http.Status +``` + +424: FAILED DEPENDENCY + +### forbidden + +```clojure +library/lux/world/net/http.Status +``` + +403: FORBIDDEN + +### found + +```clojure +library/lux/world/net/http.Status +``` + +302: FOUND + +### gateway\_timeout + +```clojure +library/lux/world/net/http.Status +``` + +504: GATEWAY TIMEOUT + +### gone + +```clojure +library/lux/world/net/http.Status +``` + +410: GONE + +### http\_version\_not\_supported + +```clojure +library/lux/world/net/http.Status +``` + +505: HTTP VERSION NOT SUPPORTED + +### im\_a\_teapot + +```clojure +library/lux/world/net/http.Status +``` + +418: IM A TEAPOT + +### im\_used + +```clojure +library/lux/world/net/http.Status +``` + +226: IM USED + +### insufficient\_storage + +```clojure +library/lux/world/net/http.Status +``` + +507: INSUFFICIENT STORAGE + +### internal\_server\_error + +```clojure +library/lux/world/net/http.Status +``` + +500: INTERNAL SERVER ERROR + +### length\_required + +```clojure +library/lux/world/net/http.Status +``` + +411: LENGTH REQUIRED + +### locked + +```clojure +library/lux/world/net/http.Status +``` + +423: LOCKED + +### loop\_detected + +```clojure +library/lux/world/net/http.Status +``` + +508: LOOP DETECTED + +### method\_not\_allowed + +```clojure +library/lux/world/net/http.Status +``` + +405: METHOD NOT ALLOWED + +### misdirected\_request + +```clojure +library/lux/world/net/http.Status +``` + +421: MISDIRECTED REQUEST + +### moved\_permanently + +```clojure +library/lux/world/net/http.Status +``` + +301: MOVED PERMANENTLY + +### multi\_status + +```clojure +library/lux/world/net/http.Status +``` + +207: MULTI STATUS + +### multiple\_choices + +```clojure +library/lux/world/net/http.Status +``` + +300: MULTIPLE CHOICES + +### network\_authentication\_required + +```clojure +library/lux/world/net/http.Status +``` + +511: NETWORK AUTHENTICATION REQUIRED + +### no\_content + +```clojure +library/lux/world/net/http.Status +``` + +204: NO CONTENT + +### non\_authoritative\_information + +```clojure +library/lux/world/net/http.Status +``` + +203: NON AUTHORITATIVE INFORMATION + +### not\_acceptable + +```clojure +library/lux/world/net/http.Status +``` + +406: NOT ACCEPTABLE + +### not\_extended + +```clojure +library/lux/world/net/http.Status +``` + +510: NOT EXTENDED + +### not\_found + +```clojure +library/lux/world/net/http.Status +``` + +404: NOT FOUND + +### not\_implemented + +```clojure +library/lux/world/net/http.Status +``` + +501: NOT IMPLEMENTED + +### not\_modified + +```clojure +library/lux/world/net/http.Status +``` + +304: NOT MODIFIED + +### ok + +```clojure +library/lux/world/net/http.Status +``` + +200: OK + +### partial\_content + +```clojure +library/lux/world/net/http.Status +``` + +206: PARTIAL CONTENT + +### payload\_too\_large + +```clojure +library/lux/world/net/http.Status +``` + +413: PAYLOAD TOO LARGE + +### payment\_required + +```clojure +library/lux/world/net/http.Status +``` + +402: PAYMENT REQUIRED + +### permanent\_redirect + +```clojure +library/lux/world/net/http.Status +``` + +308: PERMANENT REDIRECT + +### precondition\_failed + +```clojure +library/lux/world/net/http.Status +``` + +412: PRECONDITION FAILED + +### precondition\_required + +```clojure +library/lux/world/net/http.Status +``` + +428: PRECONDITION REQUIRED + +### processing + +```clojure +library/lux/world/net/http.Status +``` + +102: PROCESSING + +### proxy\_authentication\_required + +```clojure +library/lux/world/net/http.Status +``` + +407: PROXY AUTHENTICATION REQUIRED + +### range\_not\_satisfiable + +```clojure +library/lux/world/net/http.Status +``` + +416: RANGE NOT SATISFIABLE + +### request\_header\_fields\_too\_large + +```clojure +library/lux/world/net/http.Status +``` + +431: REQUEST HEADER FIELDS TOO LARGE + +### request\_timeout + +```clojure +library/lux/world/net/http.Status +``` + +408: REQUEST TIMEOUT + +### reset\_content + +```clojure +library/lux/world/net/http.Status +``` + +205: RESET CONTENT + +### see\_other + +```clojure +library/lux/world/net/http.Status +``` + +303: SEE OTHER + +### service\_unavailable + +```clojure +library/lux/world/net/http.Status +``` + +503: SERVICE UNAVAILABLE + +### switch\_proxy + +```clojure +library/lux/world/net/http.Status +``` + +306: SWITCH PROXY + +### switching\_protocols + +```clojure +library/lux/world/net/http.Status +``` + +101: SWITCHING PROTOCOLS + +### temporary\_redirect + +```clojure +library/lux/world/net/http.Status +``` + +307: TEMPORARY REDIRECT + +### too\_many\_requests + +```clojure +library/lux/world/net/http.Status +``` + +429: TOO MANY REQUESTS + +### unauthorized + +```clojure +library/lux/world/net/http.Status +``` + +401: UNAUTHORIZED + +### unavailable\_for\_legal\_reasons + +```clojure +library/lux/world/net/http.Status +``` + +451: UNAVAILABLE FOR LEGAL REASONS + +### unprocessable\_entity + +```clojure +library/lux/world/net/http.Status +``` + +422: UNPROCESSABLE ENTITY + +### unsupported\_media\_type + +```clojure +library/lux/world/net/http.Status +``` + +415: UNSUPPORTED MEDIA TYPE + +### upgrade\_required + +```clojure +library/lux/world/net/http.Status +``` + +426: UPGRADE REQUIRED + +### uri\_too\_long + +```clojure +library/lux/world/net/http.Status +``` + +414: URI TOO LONG + +### use\_proxy + +```clojure +library/lux/world/net/http.Status +``` + +305: USE PROXY + +### variant\_also\_negotiates + +```clojure +library/lux/world/net/http.Status +``` + +506: VARIANT ALSO NEGOTIATES + +___ + +# library/lux/world/net/uri + +## Definitions + +### URI + +```clojure +... .Type +(primitive "#Text") +``` + +A Uniform Resource Identifier\. + +### separator + +```clojure +.Text +``` + +A separator for the pieces of a URI\. + +___ + +# library/lux/world/output/video/resolution + +## Definitions + +### Resolution + +```clojure +... .Type +[.Nat .Nat] +``` + +A screen resolution\. + +### equivalence + +```clojure +(library/lux/abstract/equivalence.Equivalence Resolution) +``` + +### fhd + +```clojure +Resolution +``` + +FHD resolution: 1920x1080\. + +### hash + +```clojure +(library/lux/abstract/hash.Hash Resolution) +``` + +### hd\+ + +```clojure +Resolution +``` + +HD\+ resolution: 1600x900\. + +### svga + +```clojure +Resolution +``` + +SVGA resolution: 800x600\. + +### sxga + +```clojure +Resolution +``` + +SXGA resolution: 1280x1024\. + +### uhd\_4k + +```clojure +Resolution +``` + +UHD 4K resolution: 3840x2160\. + +### wqhd + +```clojure +Resolution +``` + +WQHD resolution: 2560x1440\. + +### wsvga + +```clojure +Resolution +``` + +WSVGA resolution: 1024x600\. + +### wsxga\+ + +```clojure +Resolution +``` + +WSXGA\+ resolution: 1680x1050\. + +### wuxga + +```clojure +Resolution +``` + +WUXGA resolution: 1920x1200\. + +### wxga\+ + +```clojure +Resolution +``` + +WXGA\+ resolution: 1440x900\. + +### wxga/16:10 + +```clojure +Resolution +``` + +WXGA 16:10 resolution: 1280x800\. + +### wxga/16:9 + +```clojure +Resolution +``` + +WXGA 16:9 resolution: 1280x720\. + +### wxga/5:3 + +```clojure +Resolution +``` + +WXGA 5:3 resolution: 1280x768\. + +### xga + +```clojure +Resolution +``` + +XGA resolution: 1024x768\. + +### xga\+ + +```clojure +Resolution +``` + +XGA\+ resolution: 1152x864\. + +___ + +# library/lux/world/program + +## Definitions + +### \(Program \!\) + +```clojure +... .Type +[(-> .Any (! (.List .Text))) (-> .Text (! (library/lux/control/try.Try .Text))) library/lux/world/file.Path library/lux/world/file.Path (-> library/lux/world/shell.Exit (! .Nothing))] +``` + +Access to ambient program data and the capacity to exit the program\. + +### async + +```clojure +(-> (Program library/lux/control/io.IO) (Program library/lux/control/concurrency/async.Async)) +``` + +### default + +```clojure +(Program library/lux/control/io.IO) +``` + +### environment + +```clojure +(All (_ a) (-> (library/lux/abstract/monad.Monad a) (Program a) (a library/lux/control/parser/environment.Environment))) +``` + +Assembles the environment variables available to the program\. + +```clojure +(environment monad program) +``` + +### mock + +```clojure +(-> library/lux/control/parser/environment.Environment library/lux/world/file.Path library/lux/world/file.Path (Program library/lux/control/io.IO)) +``` + +```clojure +(mock environment home directory) +``` + +### unknown\_environment\_variable + +```clojure +(library/lux/control/exception.Exception .Text) +``` + +___ + +# library/lux/world/shell + +## Definitions + +### Argument + +```clojure +... .Type +(primitive "#Text") +``` + +A parameter for a command\. + +### Command + +```clojure +... .Type +(primitive "#Text") +``` + +A command that can be executed by the operating system\. + +### Exit + +```clojure +... .Type +(primitive "#I64" (primitive "#Int")) +``` + +A program exit code\. + +### \(Mock s\) + +```clojure +... .Type +[(-> s (library/lux/control/try.Try [s .Text])) (-> s (library/lux/control/try.Try [s .Text])) (-> .Text s (library/lux/control/try.Try s)) (-> s (library/lux/control/try.Try s)) (-> s (library/lux/control/try.Try [s Exit]))] +``` + +A simulated process\. + +### \(Process \!\) + +```clojure +... .Type +[(-> .Any (! (library/lux/control/try.Try .Text))) (-> .Any (! (library/lux/control/try.Try .Text))) (-> .Text (! (library/lux/control/try.Try .Any))) (-> .Any (! (library/lux/control/try.Try .Any))) (-> .Any (! (library/lux/control/try.Try Exit)))] +``` + +The means for communicating with a program/process being executed by the operating system\. + +### \(Shell \!\) + +```clojure +... .Type +(-> [library/lux/control/parser/environment.Environment library/lux/world/file.Path Command (.List Argument)] (! (library/lux/control/try.Try (Process !)))) +``` + +The means for issuing commands to the operating system\. + +### async + +```clojure +(-> (Shell library/lux/control/io.IO) (Shell library/lux/control/concurrency/async.Async)) +``` + +### default + +```clojure +(Shell library/lux/control/io.IO) +``` + +### error + +```clojure +Exit +``` + +### mock + +```clojure +(All (_ a) (-> (-> [library/lux/control/parser/environment.Environment library/lux/world/file.Path Command (.List Argument)] (library/lux/control/try.Try (Mock a))) a (Shell library/lux/control/io.IO))) +``` + +```clojure +(mock mock init) +``` + +### no\_more\_output + +```clojure +(library/lux/control/exception.Exception .Any) +``` + +### normal + +```clojure +Exit +``` + + |