diff options
| author | Eduardo Julian | 2021-08-29 21:59:48 -0400 |
|---|---|---|
| committer | Eduardo Julian | 2021-08-29 21:59:48 -0400 |
| commit | ef437d6584d8fd863c0dab276e5a3d4dc094767b (patch) | |
| tree | e9167f045de84e7865815178e967ee85584df088 /stdlib | |
| parent | ff537895fe9c24f37a0ce11b640af5d4882571a5 (diff) | |
De-taggification | part 0
Diffstat (limited to '')
50 files changed, 325 insertions, 36817 deletions
diff --git a/stdlib/commands.md b/stdlib/commands.md index 5bee8823d..adc090c4d 100644 --- a/stdlib/commands.md +++ b/stdlib/commands.md @@ -57,7 +57,7 @@ cd ~/lux/stdlib/ \ cd ~/lux/stdlib/ \ && lux clean \ && lux with jvm with documentation build \ -&& java -jar target/program.jar > documentation.md +&& java -jar target/program.jar > ~/documentation.md ``` --- diff --git a/stdlib/documentation.md b/stdlib/documentation.md deleted file mode 100644 index 23cf7eed2..000000000 --- a/stdlib/documentation.md +++ /dev/null @@ -1,36468 +0,0 @@ -# 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 -``` - - diff --git a/stdlib/source/documentation/lux/ffi.jvm.lux b/stdlib/source/documentation/lux/ffi.jvm.lux index a781e10ff..c6d2a97ae 100644 --- a/stdlib/source/documentation/lux/ffi.jvm.lux +++ b/stdlib/source/documentation/lux/ffi.jvm.lux @@ -97,7 +97,7 @@ [])) (#public (virtual) java/lang/Object "") - (#public #static (static) java/lang/Object + (#public "static" (static) java/lang/Object "") (Runnable [] (run) void []) @@ -184,17 +184,17 @@ ["#::." (new []) (equals [java/lang/Object] boolean) - (wait [int] #io #try void)])] + (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)." + "'?' 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)]) + ("static" valueOf [char] java/lang/String) + ("static" valueOf #as int_valueOf [int] java/lang/String)]) (import: (java/util/List e) ["#::." @@ -209,7 +209,7 @@ "All enum options to be imported must be specified." (import: java/lang/Character$UnicodeScript ["#::." - (#enum ARABIC CYRILLIC LATIN)])] + ("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) @@ -218,7 +218,7 @@ (poll [] A) (wasResolved [] boolean) (waitOn [lux/Function] void) - (#static [A] make [A] (lux/concurrency/async/JvmAsync A))])] + ("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) diff --git a/stdlib/source/documentation/lux/ffi.old.lux b/stdlib/source/documentation/lux/ffi.old.lux index ac2dd546c..86e9a23b6 100644 --- a/stdlib/source/documentation/lux/ffi.old.lux +++ b/stdlib/source/documentation/lux/ffi.old.lux @@ -64,7 +64,7 @@ [])) (#public (virtual) java/lang/Object "") - (#public #static (static) java/lang/Object + (#public "static" (static) java/lang/Object "") (Runnable [] (run) void [])) @@ -148,17 +148,17 @@ ["#::." (new []) (equals [java/lang/Object] boolean) - (wait [int] #io #try void)])] + (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)." + "'?' 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)]) + ("static" valueOf [char] java/lang/String) + ("static" valueOf #as int_valueOf [int] java/lang/String)]) (import: (java/util/List e) ["#::." @@ -173,7 +173,7 @@ "All enum options to be imported must be specified." (import: java/lang/Character$UnicodeScript ["#::." - (#enum ARABIC CYRILLIC LATIN)])] + ("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-parameters." "Lux types, such as Maybe cannot be named (otherwise, they'd be confused for Java classes)." (import: (lux/concurrency/async/JvmAsync A) @@ -182,7 +182,7 @@ (poll [] A) (wasResolved [] boolean) (waitOn [lux/Function] void) - (#static [A] make [A] (lux/concurrency/async/JvmAsync A))])] + ("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) diff --git a/stdlib/source/documentation/lux/ffi.rb.lux b/stdlib/source/documentation/lux/ffi.rb.lux index 7d265ec07..a257a7b26 100644 --- a/stdlib/source/documentation/lux/ffi.rb.lux +++ b/stdlib/source/documentation/lux/ffi.rb.lux @@ -19,17 +19,17 @@ (import: File #as RubyFile ["#::." - (#static SEPARATOR ..String) - (#static open [Path ..String] #io #try RubyFile) - (#static stat [Path] #io #try Stat) - (#static delete [Path] #io #try Int) - (#static file? [Path] #io #try Bit) - (#static directory? [Path] #io #try Bit) + ("static" SEPARATOR ..String) + ("static" open [Path ..String] "io" "try" RubyFile) + ("static" stat [Path] "io" "try" Stat) + ("static" delete [Path] "io" "try" Int) + ("static" file? [Path] "io" "try" Bit) + ("static" directory? [Path] "io" "try" Bit) - (read [] #io #try Binary) - (write [Binary] #io #try Int) - (flush [] #io #try #? Any) - (close [] #io #try #? Any)])]) + (read [] "io" "try" Binary) + (write [Binary] "io" "try" Int) + (flush [] "io" "try" "?" Any) + (close [] "io" "try" "?" Any)])]) (.def: .public documentation (.List $.Module) diff --git a/stdlib/source/documentation/lux/math/infix.lux b/stdlib/source/documentation/lux/math/infix.lux index add6876f2..37f4959a3 100644 --- a/stdlib/source/documentation/lux/math/infix.lux +++ b/stdlib/source/documentation/lux/math/infix.lux @@ -20,7 +20,6 @@ [(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])]) (.def: .public documentation diff --git a/stdlib/source/library/lux/control/concurrency/thread.lux b/stdlib/source/library/lux/control/concurrency/thread.lux index d618d7270..603b44da8 100644 --- a/stdlib/source/library/lux/control/concurrency/thread.lux +++ b/stdlib/source/library/lux/control/concurrency/thread.lux @@ -26,36 +26,36 @@ (ffi.import: java/lang/Runtime ["#::." - (#static getRuntime [] java/lang/Runtime) + ("static" getRuntime [] java/lang/Runtime) (availableProcessors [] int)]) (ffi.import: java/lang/Runnable) (ffi.import: java/util/concurrent/TimeUnit ["#::." - (#enum MILLISECONDS)]) + ("enum" MILLISECONDS)]) (ffi.import: java/util/concurrent/Executor ["#::." - (execute [java/lang/Runnable] #io void)]) + (execute [java/lang/Runnable] "io" void)]) (ffi.import: (java/util/concurrent/ScheduledFuture a)) (ffi.import: java/util/concurrent/ScheduledThreadPoolExecutor ["#::." (new [int]) - (schedule [java/lang/Runnable long java/util/concurrent/TimeUnit] #io (java/util/concurrent/ScheduledFuture java/lang/Object))]))] + (schedule [java/lang/Runnable long java/util/concurrent/TimeUnit] "io" (java/util/concurrent/ScheduledFuture java/lang/Object))]))] (for {@.old (as_is <jvm>) @.jvm (as_is <jvm>) @.js - (as_is (ffi.import: (setTimeout [ffi.Function ffi.Number] #io Any))) + (as_is (ffi.import: (setTimeout [ffi.Function ffi.Number] "io" Any))) @.python (ffi.import: threading/Timer ["#::." (new [ffi.Float ffi.Function]) - (start [] #io #? Any)])} + (start [] "io" "?" Any)])} ... Default (type: Thread diff --git a/stdlib/source/library/lux/data/binary.lux b/stdlib/source/library/lux/data/binary.lux index c87d157ea..c4dd05e8e 100644 --- a/stdlib/source/library/lux/data/binary.lux +++ b/stdlib/source/library/lux/data/binary.lux @@ -40,12 +40,12 @@ (ffi.import: java/lang/System ["#::." - (#static arraycopy [java/lang/Object int java/lang/Object int int] #try void)]) + ("static" arraycopy [java/lang/Object int java/lang/Object int int] "try" void)]) (ffi.import: java/util/Arrays ["#::." - (#static copyOfRange [[byte] int int] [byte]) - (#static equals [[byte] [byte]] boolean)]) + ("static" copyOfRange [[byte] int int] [byte]) + ("static" equals [[byte] [byte]] boolean)]) (def: byte_mask I64 diff --git a/stdlib/source/library/lux/data/text/buffer.lux b/stdlib/source/library/lux/data/text/buffer.lux index e23a11f63..ddbf123c6 100644 --- a/stdlib/source/library/lux/data/text/buffer.lux +++ b/stdlib/source/library/lux/data/text/buffer.lux @@ -42,7 +42,7 @@ (join [Text] Text)])) @.lua (as_is (import: (table/concat [(array.Array Text) Text] Text)) ...https://www.lua.org/manual/5.3/manual.html#pdf-table.concat - (import: (table/insert [(array.Array Text) Text] #? Nothing)) + (import: (table/insert [(array.Array Text) Text] "?" Nothing)) ... https://www.lua.org/manual/5.3/manual.html#pdf-table.insert )} (as_is)))) diff --git a/stdlib/source/library/lux/data/text/encoding/utf8.lux b/stdlib/source/library/lux/data/text/encoding/utf8.lux index e7d9b611c..dd0881732 100644 --- a/stdlib/source/library/lux/data/text/encoding/utf8.lux +++ b/stdlib/source/library/lux/data/text/encoding/utf8.lux @@ -24,8 +24,8 @@ ... On Node (ffi.import: Buffer ["#::." - (#static from #as from|encoded [ffi.String ffi.String] Buffer) - (#static from #as from|decoded [Uint8Array] Buffer) + ("static" from #as from|encoded [ffi.String ffi.String] Buffer) + ("static" from #as from|decoded [Uint8Array] Buffer) (toString [ffi.String] ffi.String)]) ... On the browser diff --git a/stdlib/source/library/lux/debug.lux b/stdlib/source/library/lux/debug.lux index c08076bcf..531bb7cd8 100644 --- a/stdlib/source/library/lux/debug.lux +++ b/stdlib/source/library/lux/debug.lux @@ -72,10 +72,10 @@ @.js (as_is (import: JSON ["#::." - (#static stringify [.Any] ffi.String)]) + ("static" stringify [.Any] ffi.String)]) (import: Array ["#::." - (#static isArray [.Any] ffi.Boolean)])) + ("static" isArray [.Any] ffi.Boolean)])) @.python (as_is (type: PyType @@ -90,7 +90,7 @@ (import: math ["#::." - (#static type [.Any] #? ffi.String)])) + ("static" type [.Any] "?" ffi.String)])) @.ruby (as_is (import: Class) diff --git a/stdlib/source/library/lux/ffi.js.lux b/stdlib/source/library/lux/ffi.js.lux index cb2fafe6f..247894177 100644 --- a/stdlib/source/library/lux/ffi.js.lux +++ b/stdlib/source/library/lux/ffi.js.lux @@ -53,7 +53,7 @@ (def: nullable (Parser Nullable) - (let [token (' #?)] + (let [token (' "?")] (<| (<>.and (<>.parses? (<code>.this! token))) (<>.after (<>.not (<code>.this! token))) <code>.any))) @@ -71,7 +71,7 @@ (def: static! (Parser Any) - (<code>.this! (' #static))) + (<code>.this! (' "static"))) (def: field (Parser Field) @@ -103,8 +103,8 @@ <code>.local_identifier (<>.maybe (<>.after (<code>.this! (' #as)) <code>.local_identifier)) (<code>.tuple (<>.some ..nullable)) - (<>.parses? (<code>.this! (' #io))) - (<>.parses? (<code>.this! (' #try))) + (<>.parses? (<code>.this! (' "io"))) + (<>.parses? (<code>.this! (' "try"))) ..nullable)) (def: static_method diff --git a/stdlib/source/library/lux/ffi.jvm.lux b/stdlib/source/library/lux/ffi.jvm.lux index d01286a1a..e50f12602 100644 --- a/stdlib/source/library/lux/ffi.jvm.lux +++ b/stdlib/source/library/lux/ffi.jvm.lux @@ -852,7 +852,7 @@ (<code>.form (do <>.monad [pm privacy_modifier^ strict_fp? (<>.parses? (<code>.this! (' #strict))) - _ (<code>.this! (' #static)) + _ (<code>.this! (' "static")) method_vars (<>.else (list) ..vars^) .let [total_vars method_vars] [name arguments] (<code>.form (<>.and <code>.local_identifier @@ -938,20 +938,20 @@ (def: import_member_return_flags^ (Parser [Bit Bit Bit]) ($_ <>.and - (<>.parses? (<code>.this! (' #io))) - (<>.parses? (<code>.this! (' #try))) - (<>.parses? (<code>.this! (' #?))))) + (<>.parses? (<code>.this! (' "io"))) + (<>.parses? (<code>.this! (' "try"))) + (<>.parses? (<code>.this! (' "?"))))) (def: primitive_mode^ (Parser Primitive_Mode) - (<>.or (<code>.tag! ["" "manual"]) - (<code>.tag! ["" "auto"]))) + (<>.or (<code>.this! (' "manual")) + (<code>.this! (' "auto")))) (def: (import_member_decl^ owner_vars) (-> (List (Type Var)) (Parser Import_Member_Declaration)) ($_ <>.either (<code>.form (do <>.monad - [_ (<code>.this! (' #enum)) + [_ (<code>.this! (' "enum")) enum_members (<>.some <code>.local_identifier)] (in (#EnumDecl enum_members)))) (<code>.form (do <>.monad @@ -974,7 +974,7 @@ )) (<code>.form (do <>.monad [kind (: (Parser ImportMethodKind) - (<>.or (<code>.tag! ["" "static"]) + (<>.or (<code>.this! (' "static")) (in []))) tvars (<>.else (list) ..vars^) name <code>.local_identifier @@ -995,11 +995,11 @@ {#import_method_name name #import_method_return return}])))) (<code>.form (do <>.monad - [static? (<>.parses? (<code>.this! (' #static))) + [static? (<>.parses? (<code>.this! (' "static"))) name <code>.local_identifier ?prim_mode (<>.maybe primitive_mode^) gtype (..type^ owner_vars) - maybe? (<>.parses? (<code>.this! (' #?))) + maybe? (<>.parses? (<code>.this! (' "?"))) setter? (<>.parses? (<code>.this! (' #!)))] (in (#FieldAccessDecl {#import_field_mode (maybe.else #AutoPrM ?prim_mode) #import_field_name name diff --git a/stdlib/source/library/lux/ffi.lua.lux b/stdlib/source/library/lux/ffi.lua.lux index d8bcfdb42..4d9fcf6a1 100644 --- a/stdlib/source/library/lux/ffi.lua.lux +++ b/stdlib/source/library/lux/ffi.lua.lux @@ -53,7 +53,7 @@ (def: nilable (Parser Nilable) - (let [token (' #?)] + (let [token (' "?")] (<| (<>.and (<>.parses? (<code>.this! token))) (<>.after (<>.not (<code>.this! token))) <code>.any))) @@ -63,7 +63,7 @@ (def: static! (Parser Any) - (<code>.this! (' #static))) + (<code>.this! (' "static"))) (def: field (Parser Field) @@ -102,8 +102,8 @@ <code>.local_identifier (<>.maybe (<>.after (<code>.this! (' #as)) <code>.local_identifier)) (<code>.tuple (<>.some ..nilable)) - (<>.parses? (<code>.this! (' #io))) - (<>.parses? (<code>.this! (' #try))) + (<>.parses? (<code>.this! (' "io"))) + (<>.parses? (<code>.this! (' "try"))) ..nilable)) (def: static_method @@ -220,7 +220,7 @@ (syntax: .public (import: [import ..import]) {#.doc (example "Easily import types, methods, functions and constants." - (import: (os/getenv [..String] #io #? ..String)))} + (import: (os/getenv [..String] "io" "?" ..String)))} (with_identifiers [g!temp] (case import (#Class [class format members]) diff --git a/stdlib/source/library/lux/ffi.old.lux b/stdlib/source/library/lux/ffi.old.lux index 016bce2b5..a6dd4c4bf 100644 --- a/stdlib/source/library/lux/ffi.old.lux +++ b/stdlib/source/library/lux/ffi.old.lux @@ -802,7 +802,7 @@ (<code>.form (do <>.monad [pm privacy_modifier^ strict_fp? (<>.parses? (<code>.this! (' #strict))) - _ (<code>.this! (' #static)) + _ (<code>.this! (' "static")) method_vars ..type_params^ .let [total_vars method_vars] [name arg_decls] (<code>.form (<>.and <code>.local_identifier @@ -882,22 +882,22 @@ (def: (import_member_args^ type_vars) (-> (List Type_Parameter) (Parser (List [Bit GenericType]))) - (<code>.tuple (<>.some (<>.and (<>.parses? (<code>.this! (' #?))) (..generic_type^ type_vars))))) + (<code>.tuple (<>.some (<>.and (<>.parses? (<code>.this! (' "?"))) (..generic_type^ type_vars))))) (def: import_member_return_flags^ (Parser [Bit Bit Bit]) - ($_ <>.and (<>.parses? (<code>.this! (' #io))) (<>.parses? (<code>.this! (' #try))) (<>.parses? (<code>.this! (' #?))))) + ($_ <>.and (<>.parses? (<code>.this! (' "io"))) (<>.parses? (<code>.this! (' "try"))) (<>.parses? (<code>.this! (' "?"))))) (def: primitive_mode^ (Parser Primitive_Mode) - (<>.or (<code>.this! (' #manual)) - (<code>.this! (' #auto)))) + (<>.or (<code>.this! (' "manual")) + (<code>.this! (' "auto")))) (def: (import_member_decl^ owner_vars) (-> (List Type_Parameter) (Parser Import_Member_Declaration)) ($_ <>.either (<code>.form (do <>.monad - [_ (<code>.this! (' #enum)) + [_ (<code>.this! (' "enum")) enum_members (<>.some <code>.local_identifier)] (in (#EnumDecl enum_members)))) (<code>.form (do <>.monad @@ -920,7 +920,7 @@ )) (<code>.form (do <>.monad [kind (: (Parser ImportMethodKind) - (<>.or (<code>.this! (' #static)) + (<>.or (<code>.this! (' "static")) (in []))) tvars ..type_params^ name <code>.local_identifier @@ -942,11 +942,11 @@ #import_method_return return }])))) (<code>.form (do <>.monad - [static? (<>.parses? (<code>.this! (' #static))) + [static? (<>.parses? (<code>.this! (' "static"))) name <code>.local_identifier ?prim_mode (<>.maybe primitive_mode^) gtype (..generic_type^ owner_vars) - maybe? (<>.parses? (<code>.this! (' #?))) + maybe? (<>.parses? (<code>.this! (' "?"))) setter? (<>.parses? (<code>.this! (' #!)))] (in (#FieldAccessDecl {#import_field_mode (maybe.else #AutoPrM ?prim_mode) #import_field_name name diff --git a/stdlib/source/library/lux/ffi.php.lux b/stdlib/source/library/lux/ffi.php.lux index c06124708..1e7f61563 100644 --- a/stdlib/source/library/lux/ffi.php.lux +++ b/stdlib/source/library/lux/ffi.php.lux @@ -50,7 +50,7 @@ (def: nullable (Parser Nullable) - (let [token (' #?)] + (let [token (' "?")] (<| (<>.and (<>.parses? (<code>.this! token))) (<>.after (<>.not (<code>.this! token))) <code>.any))) @@ -67,7 +67,7 @@ (def: static! (Parser Any) - (<code>.this! (' #static))) + (<code>.this! (' "static"))) (def: field (Parser Field) @@ -108,8 +108,8 @@ <code>.local_identifier (<>.maybe ..alias) (<code>.tuple (<>.some ..nullable)) - (<>.parses? (<code>.this! (' #io))) - (<>.parses? (<code>.this! (' #try))) + (<>.parses? (<code>.this! (' "io"))) + (<>.parses? (<code>.this! (' "try"))) ..nullable)) (def: static_method diff --git a/stdlib/source/library/lux/ffi.py.lux b/stdlib/source/library/lux/ffi.py.lux index bf455fc2e..b523ce1e4 100644 --- a/stdlib/source/library/lux/ffi.py.lux +++ b/stdlib/source/library/lux/ffi.py.lux @@ -53,7 +53,7 @@ (def: noneable (Parser Noneable) - (let [token (' #?)] + (let [token (' "?")] (<| (<>.and (<>.parses? (<code>.this! token))) (<>.after (<>.not (<code>.this! token))) <code>.any))) @@ -71,7 +71,7 @@ (def: static! (Parser Any) - (<code>.this! (' #static))) + (<code>.this! (' "static"))) (def: field (Parser Field) @@ -103,8 +103,8 @@ <code>.local_identifier (<>.maybe (<>.after (<code>.this! (' #as)) <code>.local_identifier)) (<code>.tuple (<>.some ..noneable)) - (<>.parses? (<code>.this! (' #io))) - (<>.parses? (<code>.this! (' #try))) + (<>.parses? (<code>.this! (' "io"))) + (<>.parses? (<code>.this! (' "try"))) ..noneable)) (def: static_method @@ -222,25 +222,25 @@ {#.doc (example "Easily import types, methods, functions and constants." (import: os ["#::." - (#static F_OK ..Integer) - (#static R_OK ..Integer) - (#static W_OK ..Integer) - (#static X_OK ..Integer) - - (#static mkdir [..String] #io #try #? Any) - (#static access [..String ..Integer] #io #try ..Boolean) - (#static remove [..String] #io #try #? Any) - (#static rmdir [..String] #io #try #? Any) - (#static rename [..String ..String] #io #try #? Any) - (#static listdir [..String] #io #try (Array ..String))]) + ("static" F_OK ..Integer) + ("static" R_OK ..Integer) + ("static" W_OK ..Integer) + ("static" X_OK ..Integer) + + ("static" mkdir [..String] "io" "try" "?" Any) + ("static" access [..String ..Integer] "io" "try" ..Boolean) + ("static" remove [..String] "io" "try" "?" Any) + ("static" rmdir [..String] "io" "try" "?" Any) + ("static" rename [..String ..String] "io" "try" "?" Any) + ("static" listdir [..String] "io" "try" (Array ..String))]) (import: os/path ["#::." - (#static isfile [..String] #io #try ..Boolean) - (#static isdir [..String] #io #try ..Boolean) - (#static sep ..String) - (#static getsize [..String] #io #try ..Integer) - (#static getmtime [..String] #io #try ..Float)]))} + ("static" isfile [..String] "io" "try" ..Boolean) + ("static" isdir [..String] "io" "try" ..Boolean) + ("static" sep ..String) + ("static" getsize [..String] "io" "try" ..Integer) + ("static" getmtime [..String] "io" "try" ..Float)]))} (with_identifiers [g!temp] (case import (#Class [class format members]) diff --git a/stdlib/source/library/lux/ffi.rb.lux b/stdlib/source/library/lux/ffi.rb.lux index 3c1da5d57..62bafd5e5 100644 --- a/stdlib/source/library/lux/ffi.rb.lux +++ b/stdlib/source/library/lux/ffi.rb.lux @@ -52,7 +52,7 @@ (def: nilable (Parser Nilable) - (let [token (' #?)] + (let [token (' "?")] (<| (<>.and (<>.parses? (<code>.this! token))) (<>.after (<>.not (<code>.this! token))) <code>.any))) @@ -69,7 +69,7 @@ (def: static! (Parser Any) - (<code>.this! (' #static))) + (<code>.this! (' "static"))) (def: field (Parser Field) @@ -110,8 +110,8 @@ <code>.local_identifier (<>.maybe ..alias) (<code>.tuple (<>.some ..nilable)) - (<>.parses? (<code>.this! (' #io))) - (<>.parses? (<code>.this! (' #try))) + (<>.parses? (<code>.this! (' "io"))) + (<>.parses? (<code>.this! (' "try"))) ..nilable)) (def: static_method diff --git a/stdlib/source/library/lux/ffi.scm.lux b/stdlib/source/library/lux/ffi.scm.lux index f8f75f21e..58603cef7 100644 --- a/stdlib/source/library/lux/ffi.scm.lux +++ b/stdlib/source/library/lux/ffi.scm.lux @@ -50,7 +50,7 @@ (def: nilable (Parser Nilable) - (let [token (' #?)] + (let [token (' "?")] (<| (<>.and (<>.parses? (<code>.this! token))) (<>.after (<>.not (<code>.this! token))) <code>.any))) @@ -67,7 +67,7 @@ (def: static! (Parser Any) - (<code>.this! (' #static))) + (<code>.this! (' "static"))) (def: field (Parser Field) @@ -100,8 +100,8 @@ <code>.local_identifier (<>.maybe ..alias) (<code>.tuple (<>.some ..nilable)) - (<>.parses? (<code>.this! (' #io))) - (<>.parses? (<code>.this! (' #try))) + (<>.parses? (<code>.this! (' "io"))) + (<>.parses? (<code>.this! (' "try"))) ..nilable)) (def: input_variables diff --git a/stdlib/source/library/lux/math/infix.lux b/stdlib/source/library/lux/math/infix.lux index 207484719..fca3ed8ec 100644 --- a/stdlib/source/library/lux/math/infix.lux +++ b/stdlib/source/library/lux/math/infix.lux @@ -45,29 +45,15 @@ ..literal (<code>.form (<>.many <code>.any)) (<code>.tuple (<>.and <code>.any expression)) - (<code>.tuple ($_ <>.either - (do <>.monad - [_ (<code>.this! (' #and)) - init_subject expression - init_op <code>.any - init_param expression - steps (<>.some (<>.and <code>.any expression))] - (in (product.right (list\mix (function (_ [op param] [subject [_subject _op _param]]) - [param [(#Binary _subject _op _param) - (` and) - (#Binary subject op param)]]) - [init_param [init_subject init_op init_param]] - steps)))) - (do <>.monad - [init_subject expression - init_op <code>.any - init_param expression - steps (<>.some (<>.and <code>.any expression))] - (in (list\mix (function (_ [op param] [_subject _op _param]) - [(#Binary _subject _op _param) op param]) - [init_subject init_op init_param] - steps))) - )) + (<code>.tuple (do <>.monad + [init_subject expression + init_op <code>.any + init_param expression + steps (<>.some (<>.and <code>.any expression))] + (in (list\mix (function (_ [op param] [_subject _op _param]) + [(#Binary _subject _op _param) op param]) + [init_subject init_op init_param] + steps)))) ))) (def: (prefix infix) diff --git a/stdlib/source/library/lux/target/jvm/bytecode.lux b/stdlib/source/library/lux/target/jvm/bytecode.lux index 53886c7b5..e3c1fc9db 100644 --- a/stdlib/source/library/lux/target/jvm/bytecode.lux +++ b/stdlib/source/library/lux/target/jvm/bytecode.lux @@ -463,11 +463,11 @@ (import: java/lang/Float ["#::." - (#static floatToRawIntBits #manual [float] int)]) + ("static" floatToRawIntBits "manual" [float] int)]) (import: java/lang/Double ["#::." - (#static doubleToRawLongBits #manual [double] long)]) + ("static" doubleToRawLongBits "manual" [double] long)]) (template [<name> <type> <constructor> <constant> <wide> <to_lux> <specializations>] [(def: .public (<name> value) diff --git a/stdlib/source/library/lux/target/jvm/constant.lux b/stdlib/source/library/lux/target/jvm/constant.lux index 0775af818..63eff794c 100644 --- a/stdlib/source/library/lux/target/jvm/constant.lux +++ b/stdlib/source/library/lux/target/jvm/constant.lux @@ -67,7 +67,7 @@ (import: java/lang/Float ["#::." - (#static floatToRawIntBits #manual [float] int)]) + ("static" floatToRawIntBits "manual" [float] int)]) (implementation: .public float_equivalence (Equivalence java/lang/Float) @@ -83,7 +83,7 @@ (import: java/lang/Double ["#::." - (#static doubleToRawLongBits [double] long)]) + ("static" doubleToRawLongBits [double] long)]) (abstract: .public (Value kind) {} diff --git a/stdlib/source/library/lux/target/jvm/loader.lux b/stdlib/source/library/lux/target/jvm/loader.lux index 3d644cf5d..796e8f0f8 100644 --- a/stdlib/source/library/lux/target/jvm/loader.lux +++ b/stdlib/source/library/lux/target/jvm/loader.lux @@ -43,7 +43,7 @@ (import: java/lang/reflect/Method ["#::." - (invoke [java/lang/Object [java/lang/Object]] #try java/lang/Object)]) + (invoke [java/lang/Object [java/lang/Object]] "try" java/lang/Object)]) (import: (java/lang/Class a) ["#::." @@ -51,7 +51,7 @@ (import: java/lang/Integer ["#::." - (#static TYPE (java/lang/Class java/lang/Integer))]) + ("static" TYPE (java/lang/Class java/lang/Integer))]) (import: java/lang/reflect/AccessibleObject ["#::." @@ -60,7 +60,7 @@ (import: java/lang/ClassLoader ["#::." (loadClass [java/lang/String] - #io #try (java/lang/Class java/lang/Object))]) + "io" "try" (java/lang/Class java/lang/Object))]) (with_expansions [<elemT> (as_is (java/lang/Class java/lang/Object))] (def: java/lang/ClassLoader::defineClass diff --git a/stdlib/source/library/lux/target/jvm/reflection.lux b/stdlib/source/library/lux/target/jvm/reflection.lux index 55316e26f..dfb2ff5d1 100644 --- a/stdlib/source/library/lux/target/jvm/reflection.lux +++ b/stdlib/source/library/lux/target/jvm/reflection.lux @@ -62,10 +62,10 @@ (import: java/lang/reflect/Modifier ["#::." - (#static isStatic [int] boolean) - (#static isFinal [int] boolean) - (#static isInterface [int] boolean) - (#static isAbstract [int] boolean)]) + ("static" isStatic [int] boolean) + ("static" isFinal [int] boolean) + ("static" isInterface [int] boolean) + ("static" isAbstract [int] boolean)]) (import: java/lang/annotation/Annotation) @@ -100,14 +100,14 @@ (import: (java/lang/Class c) ["#::." - (#static forName [java/lang/String boolean java/lang/ClassLoader] #try (java/lang/Class java/lang/Object)) + ("static" forName [java/lang/String boolean java/lang/ClassLoader] "try" (java/lang/Class java/lang/Object)) (getName [] java/lang/String) (getModifiers [] int) (isAssignableFrom [(java/lang/Class java/lang/Object)] boolean) (getTypeParameters [] [(java/lang/reflect/TypeVariable (java/lang/Class c))]) (getGenericInterfaces [] [java/lang/reflect/Type]) - (getGenericSuperclass [] #? java/lang/reflect/Type) - (getDeclaredField [java/lang/String] #try java/lang/reflect/Field) + (getGenericSuperclass [] "?" java/lang/reflect/Type) + (getDeclaredField [java/lang/String] "try" java/lang/reflect/Field) (getConstructors [] [(java/lang/reflect/Constructor java/lang/Object)]) (getDeclaredMethods [] [java/lang/reflect/Method])]) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux index 30da17c13..05a6aa294 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux @@ -73,10 +73,10 @@ (import: java/lang/reflect/Modifier ["#::." - (#static isStatic [int] boolean) - (#static isFinal [int] boolean) - (#static isInterface [int] boolean) - (#static isAbstract [int] boolean)]) + ("static" isStatic [int] boolean) + ("static" isFinal [int] boolean) + ("static" isInterface [int] boolean) + ("static" isAbstract [int] boolean)]) (import: java/lang/annotation/Annotation) @@ -102,14 +102,14 @@ (import: (java/lang/Class c) ["#::." - (#static forName [java/lang/String] #try (java/lang/Class java/lang/Object)) + ("static" forName [java/lang/String] "try" (java/lang/Class java/lang/Object)) (getName [] java/lang/String) (getModifiers [] int) (isAssignableFrom [(java/lang/Class java/lang/Object)] boolean) (getTypeParameters [] [(java/lang/reflect/TypeVariable (java/lang/Class c))]) (getGenericInterfaces [] [java/lang/reflect/Type]) - (getGenericSuperclass [] #? java/lang/reflect/Type) - (getDeclaredField [java/lang/String] #try java/lang/reflect/Field) + (getGenericSuperclass [] "?" java/lang/reflect/Type) + (getDeclaredField [java/lang/String] "try" java/lang/reflect/Field) (getConstructors [] [(java/lang/reflect/Constructor java/lang/Object)]) (getDeclaredMethods [] [java/lang/reflect/Method]) (getDeclaredAnnotations [] [java/lang/annotation/Annotation])]) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/host.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/host.lux index 832fce239..e3c07cd49 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/host.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/host.lux @@ -43,10 +43,10 @@ ) (import: java/lang/reflect/Field - (get [#? java/lang/Object] #try #? java/lang/Object)) + (get ["?" java/lang/Object] "try" "?" java/lang/Object)) (import: (java/lang/Class a) - (getField [java/lang/String] #try java/lang/reflect/Field)) + (getField [java/lang/String] "try" java/lang/reflect/Field)) (import: java/lang/Object (getClass [] (java/lang/Class java/lang/Object))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/primitive.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/primitive.lux index 7a5e65744..3a278c4d4 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/primitive.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/primitive.lux @@ -74,7 +74,7 @@ (_.invokestatic $Double "valueOf" (type.method [(list type.double) $Double (list)]))) (import: java/lang/Double - (#static doubleToRawLongBits #manual [double] int)) + ("static" doubleToRawLongBits "manual" [double] int)) (def: .public (f64 value) (-> Frac (Bytecode Any)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux index e528b33a0..eb15a08a7 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux @@ -184,8 +184,8 @@ ... [[Numbers]] (host.import: java/lang/Double - (#static MIN_VALUE Double) - (#static MAX_VALUE Double)) + ("static" MIN_VALUE Double) + ("static" MAX_VALUE Double)) (template [<name> <const> <encode>] [(def: (<name> _) diff --git a/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux b/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux index 832c6f8f6..37d9f7623 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux @@ -53,12 +53,12 @@ (import: java/util/jar/Attributes ["#::." - (put [java/lang/Object java/lang/Object] #? java/lang/Object)]) + (put [java/lang/Object java/lang/Object] "?" java/lang/Object)]) (import: java/util/jar/Attributes$Name ["#::." - (#static MAIN_CLASS java/util/jar/Attributes$Name) - (#static MANIFEST_VERSION java/util/jar/Attributes$Name)]) + ("static" MAIN_CLASS java/util/jar/Attributes$Name) + ("static" MANIFEST_VERSION java/util/jar/Attributes$Name)]) (import: java/util/jar/Manifest ["#::." @@ -100,7 +100,7 @@ (import: java/util/jar/JarOutputStream ["#::." (new [java/io/OutputStream java/util/jar/Manifest]) - (putNextEntry [java/util/zip/ZipEntry] #try void)]) + (putNextEntry [java/util/zip/ZipEntry] "try" void)]) (import: java/io/ByteArrayInputStream ["#::." @@ -113,7 +113,7 @@ (import: java/util/jar/JarInputStream ["#::." (new [java/io/InputStream]) - (getNextJarEntry [] #try #? java/util/jar/JarEntry)]) + (getNextJarEntry [] "try" "?" java/util/jar/JarEntry)]) (def: byte 1) diff --git a/stdlib/source/library/lux/world/console.lux b/stdlib/source/library/lux/world/console.lux index b3b9813ed..b34096ea5 100644 --- a/stdlib/source/library/lux/world/console.lux +++ b/stdlib/source/library/lux/world/console.lux @@ -43,21 +43,21 @@ (import: java/io/Console ["#::." - (readLine [] #io #try java/lang/String)]) + (readLine [] "io" "try" java/lang/String)]) (import: java/io/InputStream ["#::." - (read [] #io #try int)]) + (read [] "io" "try" int)]) (import: java/io/PrintStream ["#::." - (print [java/lang/String] #io #try void)]) + (print [java/lang/String] "io" "try" void)]) (import: java/lang/System ["#::." - (#static console [] #io #? java/io/Console) - (#static in java/io/InputStream) - (#static out java/io/PrintStream)]) + ("static" console [] "io" "?" java/io/Console) + ("static" in java/io/InputStream) + ("static" out java/io/PrintStream)]) (template [<name>] [(exception: .public (<name>) diff --git a/stdlib/source/library/lux/world/db/jdbc.lux b/stdlib/source/library/lux/world/db/jdbc.lux index 47701f3b0..67b8d5354 100644 --- a/stdlib/source/library/lux/world/db/jdbc.lux +++ b/stdlib/source/library/lux/world/db/jdbc.lux @@ -28,27 +28,27 @@ (import: java/lang/String) (import: java/sql/ResultSet - (getRow [] #try int) - (next [] #try boolean) - (close [] #io #try void)) + (getRow [] "try" int) + (next [] "try" boolean) + (close [] "io" "try" void)) (import: java/sql/Statement - (#static NO_GENERATED_KEYS int) - (#static RETURN_GENERATED_KEYS int) - (getGeneratedKeys [] #try java/sql/ResultSet) - (close [] #io #try void)) + ("static" NO_GENERATED_KEYS int) + ("static" RETURN_GENERATED_KEYS int) + (getGeneratedKeys [] "try" java/sql/ResultSet) + (close [] "io" "try" void)) (import: java/sql/PreparedStatement - (executeUpdate [] #io #try int) - (executeQuery [] #io #try java/sql/ResultSet)) + (executeUpdate [] "io" "try" int) + (executeQuery [] "io" "try" java/sql/ResultSet)) (import: java/sql/Connection - (prepareStatement [java/lang/String int] #try java/sql/PreparedStatement) - (isValid [int] #try boolean) - (close [] #io #try void)) + (prepareStatement [java/lang/String int] "try" java/sql/PreparedStatement) + (isValid [int] "try" boolean) + (close [] "io" "try" void)) (import: java/sql/DriverManager - (#static getConnection [java/lang/String java/lang/String java/lang/String] #io #try java/sql/Connection)) + ("static" getConnection [java/lang/String java/lang/String java/lang/String] "io" "try" java/sql/Connection)) (type: .public Credentials (Record diff --git a/stdlib/source/library/lux/world/db/jdbc/input.lux b/stdlib/source/library/lux/world/db/jdbc/input.lux index f108a2fbf..633663bcf 100644 --- a/stdlib/source/library/lux/world/db/jdbc/input.lux +++ b/stdlib/source/library/lux/world/db/jdbc/input.lux @@ -23,7 +23,7 @@ (`` (import: java/sql/PreparedStatement (~~ (template [<name> <type>] - [(<name> [int <type>] #try void)] + [(<name> [int <type>] "try" void)] [setBoolean boolean] diff --git a/stdlib/source/library/lux/world/db/jdbc/output.lux b/stdlib/source/library/lux/world/db/jdbc/output.lux index 59e30845c..dd3e19751 100644 --- a/stdlib/source/library/lux/world/db/jdbc/output.lux +++ b/stdlib/source/library/lux/world/db/jdbc/output.lux @@ -25,7 +25,7 @@ (`` (import: java/sql/ResultSet (~~ (template [<method_name> <return_class>] - [(<method_name> [int] #try <return_class>)] + [(<method_name> [int] "try" <return_class>)] [getBoolean boolean] @@ -44,8 +44,8 @@ [getTime java/sql/Time] [getTimestamp java/sql/Timestamp] )) - (next [] #try boolean) - (close [] #io #try void))) + (next [] "try" boolean) + (close [] "io" "try" void))) (type: .public (Output a) (-> [Nat java/sql/ResultSet] (Try [Nat a]))) diff --git a/stdlib/source/library/lux/world/file.lux b/stdlib/source/library/lux/world/file.lux index f80d00462..6e7a2e1ed 100644 --- a/stdlib/source/library/lux/world/file.lux +++ b/stdlib/source/library/lux/world/file.lux @@ -167,41 +167,41 @@ ["#::." (new [java/lang/String]) (~~ (template [<name>] - [(<name> [] #io #try boolean)] + [(<name> [] "io" "try" boolean)] [createNewFile] [mkdir] [delete] [isFile] [isDirectory] [canRead] [canWrite] [canExecute])) - (length [] #io #try long) - (listFiles [] #io #try #? [java/io/File]) - (getAbsolutePath [] #io #try java/lang/String) - (renameTo [java/io/File] #io #try boolean) - (lastModified [] #io #try long) - (setLastModified [long] #io #try boolean) - (#static separator java/lang/String)])) + (length [] "io" "try" long) + (listFiles [] "io" "try" "?" [java/io/File]) + (getAbsolutePath [] "io" "try" java/lang/String) + (renameTo [java/io/File] "io" "try" boolean) + (lastModified [] "io" "try" long) + (setLastModified [long] "io" "try" boolean) + ("static" separator java/lang/String)])) (ffi.import: java/lang/AutoCloseable ["#::." - (close [] #io #try void)]) + (close [] "io" "try" void)]) (ffi.import: java/io/OutputStream ["#::." - (write [[byte]] #io #try void) - (flush [] #io #try void)]) + (write [[byte]] "io" "try" void) + (flush [] "io" "try" void)]) (ffi.import: java/io/FileOutputStream ["#::." - (new [java/io/File boolean] #io #try)]) + (new [java/io/File boolean] "io" "try")]) (ffi.import: java/io/InputStream ["#::." - (read [[byte]] #io #try int)]) + (read [[byte]] "io" "try" int)]) (ffi.import: java/io/FileInputStream ["#::." - (new [java/io/File] #io #try)]) + (new [java/io/File] "io" "try")]) (`` (implementation: .public default (System IO) @@ -302,7 +302,7 @@ @.js (as_is (ffi.import: Buffer ["#::." - (#static from [Binary] ..Buffer)]) + ("static" from [Binary] ..Buffer)]) (ffi.import: FileDescriptor) @@ -541,35 +541,35 @@ (ffi.import: PyFile ["#::." - (read [] #io #try Binary) - (write [Binary] #io #try #? Any) - (close [] #io #try #? Any)]) + (read [] "io" "try" Binary) + (write [Binary] "io" "try" "?" Any) + (close [] "io" "try" "?" Any)]) - (ffi.import: (open [ffi.String ffi.String] #io #try PyFile)) + (ffi.import: (open [ffi.String ffi.String] "io" "try" PyFile)) (ffi.import: (tuple [[ffi.Integer ffi.Integer]] (Tuple/2 ffi.Integer ffi.Integer))) (ffi.import: os ["#::." - (#static F_OK ffi.Integer) - (#static R_OK ffi.Integer) - (#static W_OK ffi.Integer) - (#static X_OK ffi.Integer) - - (#static mkdir [ffi.String] #io #try #? Any) - (#static access [ffi.String ffi.Integer] #io #try ffi.Boolean) - (#static remove [ffi.String] #io #try #? Any) - (#static rmdir [ffi.String] #io #try #? Any) - (#static rename [ffi.String ffi.String] #io #try #? Any) - (#static utime [ffi.String (Tuple/2 ffi.Integer ffi.Integer)] #io #try #? Any) - (#static listdir [ffi.String] #io #try (Array ffi.String))]) + ("static" F_OK ffi.Integer) + ("static" R_OK ffi.Integer) + ("static" W_OK ffi.Integer) + ("static" X_OK ffi.Integer) + + ("static" mkdir [ffi.String] "io" "try" "?" Any) + ("static" access [ffi.String ffi.Integer] "io" "try" ffi.Boolean) + ("static" remove [ffi.String] "io" "try" "?" Any) + ("static" rmdir [ffi.String] "io" "try" "?" Any) + ("static" rename [ffi.String ffi.String] "io" "try" "?" Any) + ("static" utime [ffi.String (Tuple/2 ffi.Integer ffi.Integer)] "io" "try" "?" Any) + ("static" listdir [ffi.String] "io" "try" (Array ffi.String))]) (ffi.import: os/path ["#::." - (#static isfile [ffi.String] #io #try ffi.Boolean) - (#static isdir [ffi.String] #io #try ffi.Boolean) - (#static sep ffi.String) - (#static getsize [ffi.String] #io #try ffi.Integer) - (#static getmtime [ffi.String] #io #try ffi.Float)]) + ("static" isfile [ffi.String] "io" "try" ffi.Boolean) + ("static" isdir [ffi.String] "io" "try" ffi.Boolean) + ("static" sep ffi.String) + ("static" getsize [ffi.String] "io" "try" ffi.Integer) + ("static" getmtime [ffi.String] "io" "try" ffi.Float)]) (def: python_separator (os/path::sep)) @@ -659,7 +659,7 @@ @.ruby (as_is (ffi.import: Time #as RubyTime ["#::." - (#static at [Frac] RubyTime) + ("static" at [Frac] RubyTime) (to_f [] Frac)]) (ffi.import: Stat #as RubyStat @@ -670,31 +670,31 @@ (ffi.import: File #as RubyFile ["#::." - (#static SEPARATOR ffi.String) - (#static open [Path ffi.String] #io #try RubyFile) - (#static stat [Path] #io #try RubyStat) - (#static delete [Path] #io #try Int) - (#static file? [Path] #io #try Bit) - (#static directory? [Path] #io #try Bit) - (#static utime [RubyTime RubyTime Path] #io #try Int) - - (read [] #io #try Binary) - (write [Binary] #io #try Int) - (flush [] #io #try #? Any) - (close [] #io #try #? Any)]) + ("static" SEPARATOR ffi.String) + ("static" open [Path ffi.String] "io" "try" RubyFile) + ("static" stat [Path] "io" "try" RubyStat) + ("static" delete [Path] "io" "try" Int) + ("static" file? [Path] "io" "try" Bit) + ("static" directory? [Path] "io" "try" Bit) + ("static" utime [RubyTime RubyTime Path] "io" "try" Int) + + (read [] "io" "try" Binary) + (write [Binary] "io" "try" Int) + (flush [] "io" "try" "?" Any) + (close [] "io" "try" "?" Any)]) (ffi.import: Dir #as RubyDir ["#::." - (#static open [Path] #io #try RubyDir) + ("static" open [Path] "io" "try" RubyDir) - (children [] #io #try (Array Path)) - (close [] #io #try #? Any)]) + (children [] "io" "try" (Array Path)) + (close [] "io" "try" "?" Any)]) (ffi.import: "fileutils" FileUtils #as RubyFileUtils ["#::." - (#static move [Path Path] #io #try #? Any) - (#static rmdir [Path] #io #try #? Any) - (#static mkdir [Path] #io #try #? Any)]) + ("static" move [Path Path] "io" "try" "?" Any) + ("static" rmdir [Path] "io" "try" "?" Any) + ("static" mkdir [Path] "io" "try" "?" Any)]) (def: ruby_separator Text @@ -812,26 +812,26 @@ ... (ffi.import: (unpack [ffi.String ffi.String] Binary)) ... ... https://www.php.net/manual/en/ref.filesystem.php ... ... https://www.php.net/manual/en/function.file-get-contents.php - ... (ffi.import: (file_get_contents [Path] #io #try ffi.String)) + ... (ffi.import: (file_get_contents [Path] "io" "try" ffi.String)) ... ... https://www.php.net/manual/en/function.file-put-contents.php - ... (ffi.import: (file_put_contents [Path ffi.String Int] #io #try ffi.Integer)) - ... (ffi.import: (filemtime [Path] #io #try ffi.Integer)) - ... (ffi.import: (filesize [Path] #io #try ffi.Integer)) - ... (ffi.import: (is_executable [Path] #io #try ffi.Boolean)) - ... (ffi.import: (touch [Path ffi.Integer] #io #try ffi.Boolean)) - ... (ffi.import: (rename [Path Path] #io #try ffi.Boolean)) - ... (ffi.import: (unlink [Path] #io #try ffi.Boolean)) + ... (ffi.import: (file_put_contents [Path ffi.String Int] "io" "try" ffi.Integer)) + ... (ffi.import: (filemtime [Path] "io" "try" ffi.Integer)) + ... (ffi.import: (filesize [Path] "io" "try" ffi.Integer)) + ... (ffi.import: (is_executable [Path] "io" "try" ffi.Boolean)) + ... (ffi.import: (touch [Path ffi.Integer] "io" "try" ffi.Boolean)) + ... (ffi.import: (rename [Path Path] "io" "try" ffi.Boolean)) + ... (ffi.import: (unlink [Path] "io" "try" ffi.Boolean)) ... ... https://www.php.net/manual/en/function.rmdir.php - ... (ffi.import: (rmdir [Path] #io #try ffi.Boolean)) + ... (ffi.import: (rmdir [Path] "io" "try" ffi.Boolean)) ... ... https://www.php.net/manual/en/function.scandir.php - ... (ffi.import: (scandir [Path] #io #try (Array Path))) + ... (ffi.import: (scandir [Path] "io" "try" (Array Path))) ... ... https://www.php.net/manual/en/function.is-file.php - ... (ffi.import: (is_file [Path] #io #try ffi.Boolean)) + ... (ffi.import: (is_file [Path] "io" "try" ffi.Boolean)) ... ... https://www.php.net/manual/en/function.is-dir.php - ... (ffi.import: (is_dir [Path] #io #try ffi.Boolean)) + ... (ffi.import: (is_dir [Path] "io" "try" ffi.Boolean)) ... ... https://www.php.net/manual/en/function.mkdir.php - ... (ffi.import: (mkdir [Path] #io #try ffi.Boolean)) + ... (ffi.import: (mkdir [Path] "io" "try" ffi.Boolean)) ... (def: byte_array_format "C*") ... (def: default_separator (..DIRECTORY_SEPARATOR)) diff --git a/stdlib/source/library/lux/world/file/watch.lux b/stdlib/source/library/lux/world/file/watch.lux index e5998a925..cb316fbd4 100644 --- a/stdlib/source/library/lux/world/file/watch.lux +++ b/stdlib/source/library/lux/world/file/watch.lux @@ -294,14 +294,14 @@ (import: java/nio/file/Path ["#::." - (register [java/nio/file/WatchService [(java/nio/file/WatchEvent$Kind [? < java/lang/Object])]] #io #try java/nio/file/WatchKey) + (register [java/nio/file/WatchService [(java/nio/file/WatchEvent$Kind [? < java/lang/Object])]] "io" "try" java/nio/file/WatchKey) (toString [] java/lang/String)]) (import: java/nio/file/StandardWatchEventKinds ["#::." - (#static ENTRY_CREATE (java/nio/file/WatchEvent$Kind java/nio/file/Path)) - (#static ENTRY_MODIFY (java/nio/file/WatchEvent$Kind java/nio/file/Path)) - (#static ENTRY_DELETE (java/nio/file/WatchEvent$Kind java/nio/file/Path))]) + ("static" ENTRY_CREATE (java/nio/file/WatchEvent$Kind java/nio/file/Path)) + ("static" ENTRY_MODIFY (java/nio/file/WatchEvent$Kind java/nio/file/Path)) + ("static" ENTRY_DELETE (java/nio/file/WatchEvent$Kind java/nio/file/Path))]) (def: (default_event_concern event) (All (_ a) @@ -326,10 +326,10 @@ (import: java/nio/file/WatchKey ["#::." - (reset [] #io boolean) - (cancel [] #io void) + (reset [] "io" boolean) + (cancel [] "io" void) (watchable [] java/nio/file/Watchable) - (pollEvents [] #io (java/util/List (java/nio/file/WatchEvent ?)))]) + (pollEvents [] "io" (java/util/List (java/nio/file/WatchEvent ?)))]) (def: default_key_concern (-> java/nio/file/WatchKey (IO Concern)) @@ -340,15 +340,15 @@ (import: java/nio/file/WatchService ["#::." - (poll [] #io #try #? java/nio/file/WatchKey)]) + (poll [] "io" "try" "?" java/nio/file/WatchKey)]) (import: java/nio/file/FileSystem ["#::." - (newWatchService [] #io #try java/nio/file/WatchService)]) + (newWatchService [] "io" "try" java/nio/file/WatchService)]) (import: java/nio/file/FileSystems ["#::." - (#static getDefault [] java/nio/file/FileSystem)]) + ("static" getDefault [] java/nio/file/FileSystem)]) (import: java/io/File ["#::." diff --git a/stdlib/source/library/lux/world/net/http/client.lux b/stdlib/source/library/lux/world/net/http/client.lux index 72130914c..0292ab79b 100644 --- a/stdlib/source/library/lux/world/net/http/client.lux +++ b/stdlib/source/library/lux/world/net/http/client.lux @@ -73,38 +73,38 @@ (ffi.import: java/lang/AutoCloseable ["#::." - (close [] #io #try void)]) + (close [] "io" "try" void)]) (ffi.import: java/io/InputStream) (ffi.import: java/io/OutputStream ["#::." - (flush [] #io #try void) - (write [[byte]] #io #try void)]) + (flush [] "io" "try" void) + (write [[byte]] "io" "try" void)]) (ffi.import: java/net/URLConnection ["#::." - (setDoOutput [boolean] #io #try void) - (setRequestProperty [java/lang/String java/lang/String] #io #try void) - (getInputStream [] #io #try java/io/InputStream) - (getOutputStream [] #io #try java/io/OutputStream) - (getHeaderFieldKey [int] #io #try #? java/lang/String) - (getHeaderField [int] #io #try #? java/lang/String)]) + (setDoOutput [boolean] "io" "try" void) + (setRequestProperty [java/lang/String java/lang/String] "io" "try" void) + (getInputStream [] "io" "try" java/io/InputStream) + (getOutputStream [] "io" "try" java/io/OutputStream) + (getHeaderFieldKey [int] "io" "try" "?" java/lang/String) + (getHeaderField [int] "io" "try" "?" java/lang/String)]) (ffi.import: java/net/HttpURLConnection ["#::." - (setRequestMethod [java/lang/String] #io #try void) - (getResponseCode [] #io #try int)]) + (setRequestMethod [java/lang/String] "io" "try" void) + (getResponseCode [] "io" "try" int)]) (ffi.import: java/net/URL ["#::." (new [java/lang/String]) - (openConnection [] #io #try java/net/URLConnection)]) + (openConnection [] "io" "try" java/net/URLConnection)]) (ffi.import: java/io/BufferedInputStream ["#::." (new [java/io/InputStream]) - (read [[byte] int int] #io #try int)]) + (read [[byte] int int] "io" "try" int)]) (def: jvm_method (-> //.Method Text) diff --git a/stdlib/source/library/lux/world/program.lux b/stdlib/source/library/lux/world/program.lux index 98a642fcf..9b0733ec5 100644 --- a/stdlib/source/library/lux/world/program.lux +++ b/stdlib/source/library/lux/world/program.lux @@ -129,10 +129,10 @@ (import: java/lang/System ["#::." - (#static getenv [] (java/util/Map java/lang/String java/lang/String)) - (#static getenv #as resolveEnv [java/lang/String] #io #? java/lang/String) - (#static getProperty [java/lang/String] #? java/lang/String) - (#static exit [int] #io void)]) + ("static" getenv [] (java/util/Map java/lang/String java/lang/String)) + ("static" getenv #as resolveEnv [java/lang/String] "io" "?" java/lang/String) + ("static" getProperty [java/lang/String] "?" java/lang/String) + ("static" exit [int] "io" void)]) (def: (jvm\\consume iterator) (All (_ a) (-> (java/util/Iterator a) (List a))) @@ -149,8 +149,8 @@ (import: NodeJs_Process ["#::." - (exit [ffi.Number] #io Nothing) - (cwd [] #io Path)]) + (exit [ffi.Number] "io" Nothing) + (cwd [] "io" Path)]) (def: (exit_node_js! code) (-> Exit (IO Nothing)) @@ -194,11 +194,11 @@ (import: Object ["#::." - (#static entries [Object] (Array (Array ffi.String)))]) + ("static" entries [Object] (Array (Array ffi.String)))]) (import: NodeJs_OS ["#::." - (homedir [] #io Path)]) + (homedir [] "io" Path)]) (template [<name> <path>] [(def: (<name> _) @@ -222,25 +222,25 @@ (undefined)))) @.python (as_is (import: os ["#::." - (#static getcwd [] #io ffi.String) - (#static _exit [ffi.Integer] #io Nothing)]) + ("static" getcwd [] "io" ffi.String) + ("static" _exit [ffi.Integer] "io" Nothing)]) (import: os/path ["#::." - (#static expanduser [ffi.String] #io ffi.String)]) + ("static" expanduser [ffi.String] "io" ffi.String)]) (import: os/environ ["#::." - (#static keys [] #io (Array ffi.String)) - (#static get [ffi.String] #io #? ffi.String)])) + ("static" keys [] "io" (Array ffi.String)) + ("static" get [ffi.String] "io" "?" ffi.String)])) @.lua (as_is (ffi.import: LuaFile ["#::." - (read [ffi.String] #io #? ffi.String) - (close [] #io ffi.Boolean)]) + (read [ffi.String] "io" "?" ffi.String) + (close [] "io" ffi.Boolean)]) - (ffi.import: (io/popen [ffi.String] #io #try #? LuaFile)) - (ffi.import: (os/getenv [ffi.String] #io #? ffi.String)) - (ffi.import: (os/exit [ffi.Integer] #io Nothing)) + (ffi.import: (io/popen [ffi.String] "io" "try" "?" LuaFile)) + (ffi.import: (os/getenv [ffi.String] "io" "?" ffi.String)) + (ffi.import: (os/exit [ffi.Integer] "io" Nothing)) (def: (run_command default command) (-> Text Text (IO Text)) @@ -262,39 +262,39 @@ (in default))))) @.ruby (as_is (ffi.import: Env #as RubyEnv ["#::." - (#static keys [] (Array Text)) - (#static fetch [Text] #io #? Text)]) + ("static" keys [] (Array Text)) + ("static" fetch [Text] "io" "?" Text)]) (ffi.import: "fileutils" FileUtils #as RubyFileUtils ["#::." - (#static pwd Path)]) + ("static" pwd Path)]) (ffi.import: Dir #as RubyDir ["#::." - (#static home Path)]) + ("static" home Path)]) (ffi.import: Kernel #as RubyKernel ["#::." - (#static exit [Int] #io Nothing)])) + ("static" exit [Int] "io" Nothing)])) ... @.php - ... (as_is (ffi.import: (exit [Int] #io Nothing)) + ... (as_is (ffi.import: (exit [Int] "io" Nothing)) ... ... https://www.php.net/manual/en/function.exit.php - ... (ffi.import: (getcwd [] #io ffi.String)) + ... (ffi.import: (getcwd [] "io" ffi.String)) ... ... https://www.php.net/manual/en/function.getcwd.php - ... (ffi.import: (getenv #as getenv/1 [ffi.String] #io ffi.String)) - ... (ffi.import: (getenv #as getenv/0 [] #io (Array ffi.String))) + ... (ffi.import: (getenv #as getenv/1 [ffi.String] "io" ffi.String)) + ... (ffi.import: (getenv #as getenv/0 [] "io" (Array ffi.String))) ... ... https://www.php.net/manual/en/function.getenv.php ... ... https://www.php.net/manual/en/function.array-keys.php ... (ffi.import: (array_keys [(Array ffi.String)] (Array ffi.String))) ... ) ... @.scheme - ... (as_is (ffi.import: (exit [Int] #io Nothing)) + ... (as_is (ffi.import: (exit [Int] "io" Nothing)) ... ... https://srfi.schemers.org/srfi-98/srfi-98.html ... (abstract: Pair Any) ... (abstract: PList Any) - ... (ffi.import: (get-environment-variables [] #io PList)) + ... (ffi.import: (get-environment-variables [] "io" PList)) ... (ffi.import: (car [Pair] Text)) ... (ffi.import: (cdr [Pair] Text)) ... (ffi.import: (car #as head [PList] Pair)) diff --git a/stdlib/source/library/lux/world/shell.lux b/stdlib/source/library/lux/world/shell.lux index e04977d5e..216b2c856 100644 --- a/stdlib/source/library/lux/world/shell.lux +++ b/stdlib/source/library/lux/world/shell.lux @@ -203,12 +203,12 @@ (import: java/io/Reader ["#::." - (read [] #io #try int)]) + (read [] "io" "try" int)]) (import: java/io/BufferedReader ["#::." (new [java/io/Reader]) - (readLine [] #io #try #? java/lang/String)]) + (readLine [] "io" "try" "?" java/lang/String)]) (import: java/io/InputStream) @@ -218,15 +218,15 @@ (import: java/io/OutputStream ["#::." - (write [[byte]] #io #try void)]) + (write [[byte]] "io" "try" void)]) (import: java/lang/Process ["#::." - (getInputStream [] #io #try java/io/InputStream) - (getErrorStream [] #io #try java/io/InputStream) - (getOutputStream [] #io #try java/io/OutputStream) - (destroy [] #io #try void) - (waitFor [] #io #try int)]) + (getInputStream [] "io" "try" java/io/InputStream) + (getErrorStream [] "io" "try" java/io/InputStream) + (getOutputStream [] "io" "try" java/io/OutputStream) + (destroy [] "io" "try" void) + (waitFor [] "io" "try" int)]) (exception: .public no_more_output) @@ -275,13 +275,13 @@ (import: java/lang/ProcessBuilder ["#::." (new [[java/lang/String]]) - (environment [] #try (java/util/Map java/lang/String java/lang/String)) + (environment [] "try" (java/util/Map java/lang/String java/lang/String)) (directory [java/io/File] java/lang/ProcessBuilder) - (start [] #io #try java/lang/Process)]) + (start [] "io" "try" java/lang/Process)]) (import: java/lang/System ["#::." - (#static getProperty [java/lang/String] #io #try java/lang/String)]) + ("static" getProperty [java/lang/String] "io" "try" java/lang/String)]) ... https://en.wikipedia.org/wiki/Code_injection#Shell_injection (def: windows? diff --git a/stdlib/source/program/aedifex/command/build.lux b/stdlib/source/program/aedifex/command/build.lux index 421fd7086..bcda2401b 100644 --- a/stdlib/source/program/aedifex/command/build.lux +++ b/stdlib/source/program/aedifex/command/build.lux @@ -227,7 +227,7 @@ (import: java/lang/System ["#::." - (#static getProperty [java/lang/String] #io #try java/lang/String)]) + ("static" getProperty [java/lang/String] "io" "try" java/lang/String)]) (def: windows? Bit diff --git a/stdlib/source/program/aedifex/hash.lux b/stdlib/source/program/aedifex/hash.lux index 403fdb677..d0dde1c65 100644 --- a/stdlib/source/program/aedifex/hash.lux +++ b/stdlib/source/program/aedifex/hash.lux @@ -28,7 +28,7 @@ (import: java/security/MessageDigest ["#::." - (#static getInstance [java/lang/String] java/security/MessageDigest) + ("static" getInstance [java/lang/String] java/security/MessageDigest) (digest [[byte]] [byte])]) (abstract: .public SHA-1 {} Any) diff --git a/stdlib/source/program/aedifex/repository/identity.lux b/stdlib/source/program/aedifex/repository/identity.lux index 533b4fb4e..59d0fdcba 100644 --- a/stdlib/source/program/aedifex/repository/identity.lux +++ b/stdlib/source/program/aedifex/repository/identity.lux @@ -35,7 +35,7 @@ (import: java/util/Base64 ["#::." - (#static getEncoder [] java/util/Base64$Encoder)]) + ("static" getEncoder [] java/util/Base64$Encoder)]) (def: .public (basic_auth user password) (-> User Password Text) diff --git a/stdlib/source/test/lux/documentation.lux b/stdlib/source/test/lux/documentation.lux index b35ff1fb7..3e75d2454 100644 --- a/stdlib/source/test/lux/documentation.lux +++ b/stdlib/source/test/lux/documentation.lux @@ -22,12 +22,12 @@ (syntax: (macro_error [macro <code>.any]) (function (_ compiler) - (case ((macro.expansion macro) compiler) - (#try.Failure error) - (#try.Success [compiler (list (code.text error))]) - - (#try.Success _) - (#try.Failure "OOPS!")))) + (#try.Success [compiler (list (code.bit (case ((macro.expansion macro) compiler) + (#try.Failure error) + true + + (#try.Success _) + false)))]))) (syntax: (description []) (\ meta.monad each @@ -38,7 +38,7 @@ (with_expansions ['definition_description' (..description) 'sub_description' (..description) 'super_description' (..description)] - (as_is (def: g!default + (as_is (def: .public g!default Nat 123) @@ -106,10 +106,8 @@ )) (_.cover [/.unqualified_identifier] (`` (and (~~ (template [<example>] - [(<| (text.contains? (value@ #exception.label /.unqualified_identifier)) - macro_error - <example>)] - + [(macro_error <example>)] + [(/.default g!default)] [(/.documentation: g!default (~~ (template.text ['definition_description'])))] diff --git a/stdlib/source/test/lux/ffi.js.lux b/stdlib/source/test/lux/ffi.js.lux index 7a3a1b3b1..2d3de761e 100644 --- a/stdlib/source/test/lux/ffi.js.lux +++ b/stdlib/source/test/lux/ffi.js.lux @@ -28,7 +28,7 @@ ... On Node (/.import: Buffer ["#::." - (#static from [/.String /.String] Buffer) + ("static" from [/.String /.String] Buffer) (toString [/.String] /.String)]) ... On the browser diff --git a/stdlib/source/test/lux/ffi.jvm.lux b/stdlib/source/test/lux/ffi.jvm.lux index e130626de..97ecdb7a4 100644 --- a/stdlib/source/test/lux/ffi.jvm.lux +++ b/stdlib/source/test/lux/ffi.jvm.lux @@ -235,7 +235,7 @@ (/.import: test/TestInterface1 ["#::." - (actual1 [java/lang/Boolean] #try java/lang/Long)]) + (actual1 [java/lang/Boolean] "try" java/lang/Long)]) (/.interface: test/TestInterface2 ([a] actual2 [a] a)) @@ -418,13 +418,13 @@ (#public [] (new self) [] []) ... Methods - (#public #static (actual5 {value java/lang/Long}) + (#public "static" (actual5 {value java/lang/Long}) java/lang/Long value)) (/.import: test/TestClass5 ["#::." - (#static actual5 [java/lang/Long] java/lang/Long)]) + ("static" actual5 [java/lang/Long] java/lang/Long)]) (/.class: #abstract test/TestClass6 [] ... Constructors diff --git a/stdlib/source/test/lux/ffi.lua.lux b/stdlib/source/test/lux/ffi.lua.lux index 9f78a75b4..7db49a416 100644 --- a/stdlib/source/test/lux/ffi.lua.lux +++ b/stdlib/source/test/lux/ffi.lua.lux @@ -11,7 +11,7 @@ [\\library ["." /]]) -(/.import: (os/getenv [/.String] #io #? /.String)) +(/.import: (os/getenv [/.String] "io" "?" /.String)) (def: .public test Test diff --git a/stdlib/source/test/lux/ffi.py.lux b/stdlib/source/test/lux/ffi.py.lux index 2e5e89d5e..42a80a7ec 100644 --- a/stdlib/source/test/lux/ffi.py.lux +++ b/stdlib/source/test/lux/ffi.py.lux @@ -13,8 +13,8 @@ (/.import: os ["#::." - (#static R_OK /.Integer) - (#static W_OK /.Integer)]) + ("static" R_OK /.Integer) + ("static" W_OK /.Integer)]) (def: .public test Test diff --git a/stdlib/source/test/lux/ffi.rb.lux b/stdlib/source/test/lux/ffi.rb.lux index 6e10fcce1..b9a302b50 100644 --- a/stdlib/source/test/lux/ffi.rb.lux +++ b/stdlib/source/test/lux/ffi.rb.lux @@ -11,7 +11,7 @@ (/.import: File ["#::." - (#static SEPARATOR /.String)]) + ("static" SEPARATOR /.String)]) (def: .public test Test diff --git a/stdlib/source/test/lux/math/infix.lux b/stdlib/source/test/lux/math/infix.lux index 9c8298346..f9f9475a9 100644 --- a/stdlib/source/test/lux/math/infix.lux +++ b/stdlib/source/test/lux/math/infix.lux @@ -47,18 +47,11 @@ non_numeric! (bit\= (and (n.< parameter subject) (n.< extra parameter)) - (/.infix [[subject n.< parameter] and [parameter n.< extra]])) - - and_composition! - (and (bit\= (and (n.< parameter subject) (n.< extra parameter)) - (/.infix [#and subject n.< parameter n.< extra])) - (bit\= (and (n.< parameter subject) (n.> extra parameter)) - (/.infix [#and subject n.< parameter n.> extra])))] + (/.infix [[subject n.< parameter] and [parameter n.< extra]]))] (and constant_values! unary_functions! binary_functions! multiple_binary_functions! function_call! non_numeric! - and_composition! )))))) diff --git a/stdlib/source/test/lux/math/number/frac.lux b/stdlib/source/test/lux/math/number/frac.lux index cb8d4abaa..09993f033 100644 --- a/stdlib/source/test/lux/math/number/frac.lux +++ b/stdlib/source/test/lux/math/number/frac.lux @@ -120,8 +120,8 @@ (with_expansions [<jvm> (as_is (ffi.import: java/lang/Double ["#::." - (#static doubleToRawLongBits [double] long) - (#static longBitsToDouble [long] double)]))] + ("static" doubleToRawLongBits [double] long) + ("static" longBitsToDouble [long] double)]))] (for {@.old (as_is <jvm>) @.jvm (as_is <jvm>)} (as_is))) diff --git a/stdlib/source/test/lux/target/jvm.lux b/stdlib/source/test/lux/target/jvm.lux index 6dd299f2c..2a9161c8c 100644 --- a/stdlib/source/test/lux/target/jvm.lux +++ b/stdlib/source/test/lux/target/jvm.lux @@ -67,13 +67,13 @@ (import: java/lang/Float) (import: java/lang/Double ["#::." - (#static compare [double double] int)]) + ("static" compare [double double] int)]) (import: java/lang/Character) (import: java/lang/String) (import: java/lang/reflect/Method ["#::." - (invoke [java/lang/Object [java/lang/Object]] #try java/lang/Object)]) + (invoke [java/lang/Object [java/lang/Object]] "try" java/lang/Object)]) (import: (java/lang/Class c) ["#::." |