diff options
Diffstat (limited to 'stdlib/source')
18 files changed, 1156 insertions, 398 deletions
diff --git a/stdlib/source/lux/control/concurrency/frp.lux b/stdlib/source/lux/control/concurrency/frp.lux index 4709a0cad..aea0b082a 100644 --- a/stdlib/source/lux/control/concurrency/frp.lux +++ b/stdlib/source/lux/control/concurrency/frp.lux @@ -161,7 +161,7 @@ (recur tail) #.None - (recur tail)) + (wrap [])) #.None (wrap []))))) diff --git a/stdlib/source/lux/data/collection/tree/finger.lux b/stdlib/source/lux/data/collection/tree/finger.lux index c3e20ce08..c18ff7251 100644 --- a/stdlib/source/lux/data/collection/tree/finger.lux +++ b/stdlib/source/lux/data/collection/tree/finger.lux @@ -3,6 +3,9 @@ [abstract [predicate (#+ Predicate)] ["." monoid (#+ Monoid)]] + [data + [collection + ["." list ("#\." monoid)]]] [type (#+ :by-example) [abstract (#+ abstract: :abstraction :representation)]]]) @@ -55,6 +58,26 @@ (0 #1 [left right]) (value left))) + (def: #export (tags tree) + (All [@ t v] (-> (Tree @ t v) (List t))) + (case (get@ #root (:representation tree)) + (0 #0 value) + (list (get@ #tag (:representation tree))) + + (0 #1 [left right]) + (list\compose (tags left) + (tags right)))) + + (def: #export (values tree) + (All [@ t v] (-> (Tree @ t v) (List v))) + (case (get@ #root (:representation tree)) + (0 #0 value) + (list value) + + (0 #1 [left right]) + (list\compose (values left) + (values right)))) + (def: #export (search predicate tree) (All [@ t v] (-> (Predicate t) (Tree @ t v) (Maybe v))) (let [[monoid tag root] (:representation tree)] diff --git a/stdlib/source/lux/data/maybe.lux b/stdlib/source/lux/data/maybe.lux index 7b6f3ace4..6584eaf6a 100644 --- a/stdlib/source/lux/data/maybe.lux +++ b/stdlib/source/lux/data/maybe.lux @@ -125,14 +125,13 @@ +20)} (case tokens (^ (list else maybe)) - (let [g!temp (: Code [location.dummy (#.Identifier ["" ""])]) - code (` (case (~ maybe) - (#.Some (~ g!temp)) - (~ g!temp) - - #.None - (~ else)))] - (#.Right [state (list code)])) + (let [g!temp (: Code [location.dummy (#.Identifier ["" ""])])] + (#.Right [state (list (` (case (~ maybe) + (#.Some (~ g!temp)) + (~ g!temp) + + #.None + (~ else))))])) _ (#.Left "Wrong syntax for default"))) diff --git a/stdlib/source/lux/data/text/unicode.lux b/stdlib/source/lux/data/text/unicode.lux index 00c67f2c1..2aad089b9 100644 --- a/stdlib/source/lux/data/text/unicode.lux +++ b/stdlib/source/lux/data/text/unicode.lux @@ -1,196 +1,21 @@ (.module: [lux #* [abstract - [monoid (#+ Monoid)] - ["." interval (#+ Interval)]] + [equivalence (#+ Equivalence)]] [data - [number (#+ hex) - ["n" nat ("#\." interval)]] [collection ["." list ("#\." fold functor)] + ["." set ("#\." equivalence)] ["." tree #_ ["#" finger (#+ Tree)]]]] [type (#+ :by-example) abstract]] - [// (#+ Char)]) - -(abstract: #export Segment - (Interval Char) - - (structure: monoid - (Monoid Segment) - - (def: identity - (:abstraction (interval.between n.enum n\top n\bottom))) - (def: (compose left right) - (let [left (:representation left) - right (:representation right)] - (:abstraction - (interval.between n.enum - (n.min (\ left bottom) - (\ right bottom)) - (n.max (\ left top) - (\ right top))))))) - - (def: #export (segment start end) - (-> Char Char Segment) - (:abstraction (interval.between n.enum (n.min start end) (n.max start end)))) - - (template [<name> <slot>] - [(def: #export <name> - (-> Segment Char) - (|>> :representation (get@ <slot>)))] - - [start #interval.bottom] - [end #interval.top] - ) - - (def: #export (size segment) - (-> Segment Nat) - (let [start (get@ #interval.bottom (:representation segment)) - end (get@ #interval.top (:representation segment))] - (|> end (n.- start) inc))) - - (def: #export (within? segment char) - (All [a] (-> Segment Char Bit)) - (interval.within? (:representation segment) char)) - ) - -(template [<name> <start> <end>] - [(def: #export <name> Segment (..segment (hex <start>) (hex <end>)))] - - ## Normal segments - [basic-latin "0000" "007F"] - [latin-1-supplement "00A0" "00FF"] - [latin-extended-a "0100" "017F"] - [latin-extended-b "0180" "024F"] - [ipa-extensions "0250" "02AF"] - [spacing-modifier-letters "02B0" "02FF"] - [combining-diacritical-marks "0300" "036F"] - [greek-and-coptic "0370" "03FF"] - [cyrillic "0400" "04FF"] - [cyrillic-supplementary "0500" "052F"] - [armenian "0530" "058F"] - [hebrew "0590" "05FF"] - [arabic "0600" "06FF"] - [syriac "0700" "074F"] - [thaana "0780" "07BF"] - [devanagari "0900" "097F"] - [bengali "0980" "09FF"] - [gurmukhi "0A00" "0A7F"] - [gujarati "0A80" "0AFF"] - [oriya "0B00" "0B7F"] - [tamil "0B80" "0BFF"] - [telugu "0C00" "0C7F"] - [kannada "0C80" "0CFF"] - [malayalam "0D00" "0D7F"] - [sinhala "0D80" "0DFF"] - [thai "0E00" "0E7F"] - [lao "0E80" "0EFF"] - [tibetan "0F00" "0FFF"] - [myanmar "1000" "109F"] - [georgian "10A0" "10FF"] - [hangul-jamo "1100" "11FF"] - [ethiopic "1200" "137F"] - [cherokee "13A0" "13FF"] - [unified-canadian-aboriginal-syllabics "1400" "167F"] - [ogham "1680" "169F"] - [runic "16A0" "16FF"] - [tagalog "1700" "171F"] - [hanunoo "1720" "173F"] - [buhid "1740" "175F"] - [tagbanwa "1760" "177F"] - [khmer "1780" "17FF"] - [mongolian "1800" "18AF"] - [limbu "1900" "194F"] - [tai-le "1950" "197F"] - [khmer-symbols "19E0" "19FF"] - [phonetic-extensions "1D00" "1D7F"] - [latin-extended-additional "1E00" "1EFF"] - [greek-extended "1F00" "1FFF"] - [general-punctuation "2000" "206F"] - [superscripts-and-subscripts "2070" "209F"] - [currency-symbols "20A0" "20CF"] - [combining-diacritical-marks-for-symbols "20D0" "20FF"] - [letterlike-symbols "2100" "214F"] - [number-forms "2150" "218F"] - [arrows "2190" "21FF"] - [mathematical-operators "2200" "22FF"] - [miscellaneous-technical "2300" "23FF"] - [control-pictures "2400" "243F"] - [optical-character-recognition "2440" "245F"] - [enclosed-alphanumerics "2460" "24FF"] - [box-drawing "2500" "257F"] - [block-elements "2580" "259F"] - [geometric-shapes "25A0" "25FF"] - [miscellaneous-symbols "2600" "26FF"] - [dingbats "2700" "27BF"] - [miscellaneous-mathematical-symbols-a "27C0" "27EF"] - [supplemental-arrows-a "27F0" "27FF"] - [braille-patterns "2800" "28FF"] - [supplemental-arrows-b "2900" "297F"] - [miscellaneous-mathematical-symbols-b "2980" "29FF"] - [supplemental-mathematical-operators "2A00" "2AFF"] - [miscellaneous-symbols-and-arrows "2B00" "2BFF"] - [cjk-radicals-supplement "2E80" "2EFF"] - [kangxi-radicals "2F00" "2FDF"] - [ideographic-description-characters "2FF0" "2FFF"] - [cjk-symbols-and-punctuation "3000" "303F"] - [hiragana "3040" "309F"] - [katakana "30A0" "30FF"] - [bopomofo "3100" "312F"] - [hangul-compatibility-jamo "3130" "318F"] - [kanbun "3190" "319F"] - [bopomofo-extended "31A0" "31BF"] - [katakana-phonetic-extensions "31F0" "31FF"] - [enclosed-cjk-letters-and-months "3200" "32FF"] - [cjk-compatibility "3300" "33FF"] - [cjk-unified-ideographs-extension-a "3400" "4DBF"] - [yijing-hexagram-symbols "4DC0" "4DFF"] - [cjk-unified-ideographs "4E00" "9FFF"] - [yi-syllables "A000" "A48F"] - [yi-radicals "A490" "A4CF"] - [hangul-syllables "AC00" "D7AF"] - [high-surrogates "D800" "DB7F"] - [high-private-use-surrogates "DB80" "DBFF"] - [low-surrogates "DC00" "DFFF"] - [private-use-area "E000" "F8FF"] - [cjk-compatibility-ideographs "F900" "FAFF"] - [alphabetic-presentation-forms "FB00" "FB4F"] - [arabic-presentation-forms-a "FB50" "FDFF"] - [variation-selectors "FE00" "FE0F"] - [combining-half-marks "FE20" "FE2F"] - [cjk-compatibility-forms "FE30" "FE4F"] - [small-form-variants "FE50" "FE6F"] - [arabic-presentation-forms-b "FE70" "FEFF"] - [halfwidth-and-fullwidth-forms "FF00" "FFEF"] - [specials "FFF0" "FFFF"] - ## [linear-b-syllabary "10000" "1007F"] - ## [linear-b-ideograms "10080" "100FF"] - ## [aegean-numbers "10100" "1013F"] - ## [old-italic "10300" "1032F"] - ## [gothic "10330" "1034F"] - ## [ugaritic "10380" "1039F"] - ## [deseret "10400" "1044F"] - ## [shavian "10450" "1047F"] - ## [osmanya "10480" "104AF"] - ## [cypriot-syllabary "10800" "1083F"] - ## [byzantine-musical-symbols "1D000" "1D0FF"] - ## [musical-symbols "1D100" "1D1FF"] - ## [tai-xuan-jing-symbols "1D300" "1D35F"] - ## [mathematical-alphanumeric-symbols "1D400" "1D7FF"] - ## [cjk-unified-ideographs-extension-b "20000" "2A6DF"] - ## [cjk-compatibility-ideographs-supplement "2F800" "2FA1F"] - ## [tags "E0000" "E007F"] - - ## Specialized segments - [basic-latin/decimal "0030" "0039"] - [basic-latin/upper-alpha "0041" "005A"] - [basic-latin/lower-alpha "0061" "007A"] - ) + ["." / #_ + ["#." segment (#+ Segment)] + [// (#+ Char)]]) (def: builder - (tree.builder ..monoid)) + (tree.builder /segment.monoid)) (def: :@: (:by-example [@] @@ -218,131 +43,131 @@ (list\fold ..compose (..singleton head) (list\map ..singleton tail))) (def: half/0 - (..set [basic-latin - (list latin-1-supplement - latin-extended-a - latin-extended-b - ipa-extensions - spacing-modifier-letters - combining-diacritical-marks - greek-and-coptic - cyrillic - cyrillic-supplementary - armenian - hebrew - arabic - syriac - thaana - devanagari - bengali - gurmukhi - gujarati - oriya - tamil - telugu - kannada - malayalam - sinhala - thai - lao - tibetan - myanmar - georgian - hangul-jamo - ethiopic - cherokee - unified-canadian-aboriginal-syllabics - ogham - runic - tagalog - hanunoo - buhid - tagbanwa - khmer - mongolian - limbu - tai-le - khmer-symbols - phonetic-extensions - latin-extended-additional - greek-extended - general-punctuation - superscripts-and-subscripts - currency-symbols - combining-diacritical-marks-for-symbols - letterlike-symbols - number-forms - arrows - mathematical-operators - miscellaneous-technical - control-pictures - optical-character-recognition - enclosed-alphanumerics - box-drawing + (..set [/segment.basic-latin + (list /segment.latin-1-supplement + /segment.latin-extended-a + /segment.latin-extended-b + /segment.ipa-extensions + /segment.spacing-modifier-letters + /segment.combining-diacritical-marks + /segment.greek-and-coptic + /segment.cyrillic + /segment.cyrillic-supplementary + /segment.armenian + /segment.hebrew + /segment.arabic + /segment.syriac + /segment.thaana + /segment.devanagari + /segment.bengali + /segment.gurmukhi + /segment.gujarati + /segment.oriya + /segment.tamil + /segment.telugu + /segment.kannada + /segment.malayalam + /segment.sinhala + /segment.thai + /segment.lao + /segment.tibetan + /segment.myanmar + /segment.georgian + /segment.hangul-jamo + /segment.ethiopic + /segment.cherokee + /segment.unified-canadian-aboriginal-syllabics + /segment.ogham + /segment.runic + /segment.tagalog + /segment.hanunoo + /segment.buhid + /segment.tagbanwa + /segment.khmer + /segment.mongolian + /segment.limbu + /segment.tai-le + /segment.khmer-symbols + /segment.phonetic-extensions + /segment.latin-extended-additional + /segment.greek-extended + /segment.general-punctuation + /segment.superscripts-and-subscripts + /segment.currency-symbols + /segment.combining-diacritical-marks-for-symbols + /segment.letterlike-symbols + /segment.number-forms + /segment.arrows + /segment.mathematical-operators + /segment.miscellaneous-technical + /segment.control-pictures + /segment.optical-character-recognition + /segment.enclosed-alphanumerics + /segment.box-drawing )])) (def: half/1 - (..set [block-elements - (list geometric-shapes - miscellaneous-symbols - dingbats - miscellaneous-mathematical-symbols-a - supplemental-arrows-a - braille-patterns - supplemental-arrows-b - miscellaneous-mathematical-symbols-b - supplemental-mathematical-operators - miscellaneous-symbols-and-arrows - cjk-radicals-supplement - kangxi-radicals - ideographic-description-characters - cjk-symbols-and-punctuation - hiragana - katakana - bopomofo - hangul-compatibility-jamo - kanbun - bopomofo-extended - katakana-phonetic-extensions - enclosed-cjk-letters-and-months - cjk-compatibility - cjk-unified-ideographs-extension-a - yijing-hexagram-symbols - cjk-unified-ideographs - yi-syllables - yi-radicals - hangul-syllables - ## high-surrogates - ## high-private-use-surrogates - ## low-surrogates - ## private-use-area - cjk-compatibility-ideographs - alphabetic-presentation-forms - arabic-presentation-forms-a - variation-selectors - combining-half-marks - cjk-compatibility-forms - small-form-variants - arabic-presentation-forms-b - halfwidth-and-fullwidth-forms - specials - ## linear-b-syllabary - ## linear-b-ideograms - ## aegean-numbers - ## old-italic - ## gothic - ## ugaritic - ## deseret - ## shavian - ## osmanya - ## cypriot-syllabary - ## byzantine-musical-symbols - ## musical-symbols - ## tai-xuan-jing-symbols - ## mathematical-alphanumeric-symbols - ## cjk-unified-ideographs-extension-b - ## cjk-compatibility-ideographs-supplement - ## tags + (..set [/segment.block-elements + (list /segment.geometric-shapes + /segment.miscellaneous-symbols + /segment.dingbats + /segment.miscellaneous-mathematical-symbols-a + /segment.supplemental-arrows-a + /segment.braille-patterns + /segment.supplemental-arrows-b + /segment.miscellaneous-mathematical-symbols-b + /segment.supplemental-mathematical-operators + /segment.miscellaneous-symbols-and-arrows + /segment.cjk-radicals-supplement + /segment.kangxi-radicals + /segment.ideographic-description-characters + /segment.cjk-symbols-and-punctuation + /segment.hiragana + /segment.katakana + /segment.bopomofo + /segment.hangul-compatibility-jamo + /segment.kanbun + /segment.bopomofo-extended + /segment.katakana-phonetic-extensions + /segment.enclosed-cjk-letters-and-months + /segment.cjk-compatibility + /segment.cjk-unified-ideographs-extension-a + /segment.yijing-hexagram-symbols + /segment.cjk-unified-ideographs + /segment.yi-syllables + /segment.yi-radicals + /segment.hangul-syllables + ## /segment.high-surrogates + ## /segment.high-private-use-surrogates + ## /segment.low-surrogates + ## /segment.private-use-area + /segment.cjk-compatibility-ideographs + /segment.alphabetic-presentation-forms + /segment.arabic-presentation-forms-a + /segment.variation-selectors + /segment.combining-half-marks + /segment.cjk-compatibility-forms + /segment.small-form-variants + /segment.arabic-presentation-forms-b + /segment.halfwidth-and-fullwidth-forms + /segment.specials + ## /segment.linear-b-syllabary + ## /segment.linear-b-ideograms + ## /segment.aegean-numbers + ## /segment.old-italic + ## /segment.gothic + ## /segment.ugaritic + ## /segment.deseret + ## /segment.shavian + ## /segment.osmanya + ## /segment.cypriot-syllabary + ## /segment.byzantine-musical-symbols + ## /segment.musical-symbols + ## /segment.tai-xuan-jing-symbols + ## /segment.mathematical-alphanumeric-symbols + ## /segment.cjk-unified-ideographs-extension-b + ## /segment.cjk-compatibility-ideographs-supplement + ## /segment.tags )])) (def: #export full @@ -351,13 +176,13 @@ (def: #export (range set) (-> Set [Char Char]) (let [tag (tree.tag (:representation set))] - [(..start tag) - (..end tag)])) + [(/segment.start tag) + (/segment.end tag)])) (def: #export (member? set character) (-> Set Char Bit) (loop [tree (:representation set)] - (if (..within? (tree.tag tree) character) + (if (/segment.within? (tree.tag tree) character) (case (tree.root tree) (0 #0 _) true @@ -366,15 +191,22 @@ (or (recur left) (recur right))) false))) + + (structure: #export equivalence + (Equivalence Set) + + (def: (= reference subject) + (set\= (set.from-list /segment.hash (tree.tags (:representation reference))) + (set.from-list /segment.hash (tree.tags (:representation subject)))))) ) (template [<name> <segments>] [(def: #export <name> (..set <segments>))] - [ascii [basic-latin (list)]] - [ascii/alpha [basic-latin/upper-alpha (list basic-latin/lower-alpha)]] - [ascii/alpha-num [basic-latin/upper-alpha (list basic-latin/lower-alpha basic-latin/decimal)]] - [ascii/upper-alpha [basic-latin/upper-alpha (list)]] - [ascii/lower-alpha [basic-latin/lower-alpha (list)]] + [ascii [/segment.basic-latin (list)]] + [ascii/alpha [/segment.basic-latin/upper-alpha (list /segment.basic-latin/lower-alpha)]] + [ascii/alpha-num [/segment.basic-latin/upper-alpha (list /segment.basic-latin/lower-alpha /segment.basic-latin/decimal)]] + [ascii/upper-alpha [/segment.basic-latin/upper-alpha (list)]] + [ascii/lower-alpha [/segment.basic-latin/lower-alpha (list)]] ) diff --git a/stdlib/source/lux/data/text/unicode/segment.lux b/stdlib/source/lux/data/text/unicode/segment.lux new file mode 100644 index 000000000..a2507cc1e --- /dev/null +++ b/stdlib/source/lux/data/text/unicode/segment.lux @@ -0,0 +1,204 @@ +(.module: + [lux #* + [abstract + [equivalence (#+ Equivalence)] + [hash (#+ Hash)] + [monoid (#+ Monoid)] + ["." interval (#+ Interval)]] + [data + [number (#+ hex) + ["n" nat ("#\." interval)] + ["." i64]]] + [type + abstract]] + [/// (#+ Char)]) + +(abstract: #export Segment + (Interval Char) + + (structure: #export monoid + (Monoid Segment) + + (def: identity + (:abstraction (interval.between n.enum n\top n\bottom))) + (def: (compose left right) + (let [left (:representation left) + right (:representation right)] + (:abstraction + (interval.between n.enum + (n.min (\ left bottom) + (\ right bottom)) + (n.max (\ left top) + (\ right top))))))) + + (def: #export (segment start end) + (-> Char Char Segment) + (:abstraction (interval.between n.enum (n.min start end) (n.max start end)))) + + (template [<name> <slot>] + [(def: #export <name> + (-> Segment Char) + (|>> :representation (get@ <slot>)))] + + [start #interval.bottom] + [end #interval.top] + ) + + (def: #export (size segment) + (-> Segment Nat) + (let [start (get@ #interval.bottom (:representation segment)) + end (get@ #interval.top (:representation segment))] + (|> end (n.- start) inc))) + + (def: #export (within? segment char) + (All [a] (-> Segment Char Bit)) + (interval.within? (:representation segment) char)) + ) + +(structure: #export equivalence + (Equivalence Segment) + + (def: (= reference subject) + (and (n.= (..start reference) (..start subject)) + (n.= (..end reference) (..end subject))))) + +(structure: #export hash + (Hash Segment) + + (def: &equivalence ..equivalence) + (def: (hash value) + (i64.or (i64.left-shift 32 (..start value)) + (..end value)))) + +(template [<name> <start> <end>] + [(def: #export <name> Segment (..segment (hex <start>) (hex <end>)))] + + ## Normal segments + [basic-latin "0000" "007F"] + [latin-1-supplement "00A0" "00FF"] + [latin-extended-a "0100" "017F"] + [latin-extended-b "0180" "024F"] + [ipa-extensions "0250" "02AF"] + [spacing-modifier-letters "02B0" "02FF"] + [combining-diacritical-marks "0300" "036F"] + [greek-and-coptic "0370" "03FF"] + [cyrillic "0400" "04FF"] + [cyrillic-supplementary "0500" "052F"] + [armenian "0530" "058F"] + [hebrew "0590" "05FF"] + [arabic "0600" "06FF"] + [syriac "0700" "074F"] + [thaana "0780" "07BF"] + [devanagari "0900" "097F"] + [bengali "0980" "09FF"] + [gurmukhi "0A00" "0A7F"] + [gujarati "0A80" "0AFF"] + [oriya "0B00" "0B7F"] + [tamil "0B80" "0BFF"] + [telugu "0C00" "0C7F"] + [kannada "0C80" "0CFF"] + [malayalam "0D00" "0D7F"] + [sinhala "0D80" "0DFF"] + [thai "0E00" "0E7F"] + [lao "0E80" "0EFF"] + [tibetan "0F00" "0FFF"] + [myanmar "1000" "109F"] + [georgian "10A0" "10FF"] + [hangul-jamo "1100" "11FF"] + [ethiopic "1200" "137F"] + [cherokee "13A0" "13FF"] + [unified-canadian-aboriginal-syllabics "1400" "167F"] + [ogham "1680" "169F"] + [runic "16A0" "16FF"] + [tagalog "1700" "171F"] + [hanunoo "1720" "173F"] + [buhid "1740" "175F"] + [tagbanwa "1760" "177F"] + [khmer "1780" "17FF"] + [mongolian "1800" "18AF"] + [limbu "1900" "194F"] + [tai-le "1950" "197F"] + [khmer-symbols "19E0" "19FF"] + [phonetic-extensions "1D00" "1D7F"] + [latin-extended-additional "1E00" "1EFF"] + [greek-extended "1F00" "1FFF"] + [general-punctuation "2000" "206F"] + [superscripts-and-subscripts "2070" "209F"] + [currency-symbols "20A0" "20CF"] + [combining-diacritical-marks-for-symbols "20D0" "20FF"] + [letterlike-symbols "2100" "214F"] + [number-forms "2150" "218F"] + [arrows "2190" "21FF"] + [mathematical-operators "2200" "22FF"] + [miscellaneous-technical "2300" "23FF"] + [control-pictures "2400" "243F"] + [optical-character-recognition "2440" "245F"] + [enclosed-alphanumerics "2460" "24FF"] + [box-drawing "2500" "257F"] + [block-elements "2580" "259F"] + [geometric-shapes "25A0" "25FF"] + [miscellaneous-symbols "2600" "26FF"] + [dingbats "2700" "27BF"] + [miscellaneous-mathematical-symbols-a "27C0" "27EF"] + [supplemental-arrows-a "27F0" "27FF"] + [braille-patterns "2800" "28FF"] + [supplemental-arrows-b "2900" "297F"] + [miscellaneous-mathematical-symbols-b "2980" "29FF"] + [supplemental-mathematical-operators "2A00" "2AFF"] + [miscellaneous-symbols-and-arrows "2B00" "2BFF"] + [cjk-radicals-supplement "2E80" "2EFF"] + [kangxi-radicals "2F00" "2FDF"] + [ideographic-description-characters "2FF0" "2FFF"] + [cjk-symbols-and-punctuation "3000" "303F"] + [hiragana "3040" "309F"] + [katakana "30A0" "30FF"] + [bopomofo "3100" "312F"] + [hangul-compatibility-jamo "3130" "318F"] + [kanbun "3190" "319F"] + [bopomofo-extended "31A0" "31BF"] + [katakana-phonetic-extensions "31F0" "31FF"] + [enclosed-cjk-letters-and-months "3200" "32FF"] + [cjk-compatibility "3300" "33FF"] + [cjk-unified-ideographs-extension-a "3400" "4DBF"] + [yijing-hexagram-symbols "4DC0" "4DFF"] + [cjk-unified-ideographs "4E00" "9FFF"] + [yi-syllables "A000" "A48F"] + [yi-radicals "A490" "A4CF"] + [hangul-syllables "AC00" "D7AF"] + [high-surrogates "D800" "DB7F"] + [high-private-use-surrogates "DB80" "DBFF"] + [low-surrogates "DC00" "DFFF"] + [private-use-area "E000" "F8FF"] + [cjk-compatibility-ideographs "F900" "FAFF"] + [alphabetic-presentation-forms "FB00" "FB4F"] + [arabic-presentation-forms-a "FB50" "FDFF"] + [variation-selectors "FE00" "FE0F"] + [combining-half-marks "FE20" "FE2F"] + [cjk-compatibility-forms "FE30" "FE4F"] + [small-form-variants "FE50" "FE6F"] + [arabic-presentation-forms-b "FE70" "FEFF"] + [halfwidth-and-fullwidth-forms "FF00" "FFEF"] + [specials "FFF0" "FFFF"] + ## [linear-b-syllabary "10000" "1007F"] + ## [linear-b-ideograms "10080" "100FF"] + ## [aegean-numbers "10100" "1013F"] + ## [old-italic "10300" "1032F"] + ## [gothic "10330" "1034F"] + ## [ugaritic "10380" "1039F"] + ## [deseret "10400" "1044F"] + ## [shavian "10450" "1047F"] + ## [osmanya "10480" "104AF"] + ## [cypriot-syllabary "10800" "1083F"] + ## [byzantine-musical-symbols "1D000" "1D0FF"] + ## [musical-symbols "1D100" "1D1FF"] + ## [tai-xuan-jing-symbols "1D300" "1D35F"] + ## [mathematical-alphanumeric-symbols "1D400" "1D7FF"] + ## [cjk-unified-ideographs-extension-b "20000" "2A6DF"] + ## [cjk-compatibility-ideographs-supplement "2F800" "2FA1F"] + ## [tags "E0000" "E007F"] + + ## Specialized segments + [basic-latin/decimal "0030" "0039"] + [basic-latin/upper-alpha "0041" "005A"] + [basic-latin/lower-alpha "0061" "007A"] + ) diff --git a/stdlib/source/program/aedifex/artifact/extension.lux b/stdlib/source/program/aedifex/artifact/extension.lux index 78939260a..e108a3727 100644 --- a/stdlib/source/program/aedifex/artifact/extension.lux +++ b/stdlib/source/program/aedifex/artifact/extension.lux @@ -1,7 +1,7 @@ (.module: - [lux #* + [lux (#- type) [data - [text + ["." text ["%" format (#+ format)]]] [macro ["." template]]] @@ -18,6 +18,10 @@ (-> //.Type Extension) (|>> (format ..separator))) +(def: #export type + (-> Extension //.Type) + (text.replace-all ..separator "")) + (template [<name>] [(def: #export <name> Extension diff --git a/stdlib/source/program/aedifex/metadata/snapshot.lux b/stdlib/source/program/aedifex/metadata/snapshot.lux new file mode 100644 index 000000000..a94ac33c4 --- /dev/null +++ b/stdlib/source/program/aedifex/metadata/snapshot.lux @@ -0,0 +1,286 @@ +(.module: + [lux (#- Name Type) + [abstract + [monad (#+ do)] + [equivalence (#+ Equivalence)]] + [control + ["." exception (#+ exception:)] + ["<>" parser + ["<.>" xml (#+ Parser)] + ["<.>" text]]] + [data + ["." product] + ["." text + ["%" format (#+ format)]] + [number + ["n" nat]] + [format + ["." xml (#+ XML)]] + [collection + ["." list ("#\." functor)]]] + ["." time (#+ Time) + ["." instant (#+ Instant)] + ["." date (#+ Date)] + ["." year] + ["." month]]] + ["." /// #_ + ["#." artifact (#+ Group Name Version Artifact) + ["#/." type (#+ Type)]]]) + +(def: snapshot + "SNAPSHOT") + +(type: #export Time-Stamp + Instant) + +(type: #export Build + Nat) + +(type: #export Versioning + {#time-stamp Time-Stamp + #build Build + #snapshot (List Type)}) + +(type: #export Value + [Version Time-Stamp Build]) + +(type: #export Metadata + {#group Group + #name Name + #version Version + #versioning Versioning}) + +(def: (pad value) + (-> Nat Text) + (if (n.< 10 value) + (format "0" (%.nat value)) + (%.nat value))) + +(def: (date-format value) + (%.Format Date) + (format (|> value date.year year.value .nat %.nat) + (|> value date.month month.number ..pad) + (|> value date.day-of-month ..pad))) + +(def: (time-format value) + (%.Format Time) + (let [(^slots [#time.hour #time.minute #time.second]) (time.clock value)] + (format (..pad hour) + (..pad minute) + (..pad second)))) + +(def: (instant-format value) + (%.Format Instant) + (format (..date-format (instant.date value)) + (..time-format (instant.time value)))) + +(template [<separator> <name>] + [(def: <name> + <separator>)] + + ["." time-stamp-separator] + ["-" value-separator] + ) + +(def: (time-stamp-format value) + (%.Format Time-Stamp) + (format (..date-format (instant.date value)) + ..time-stamp-separator + (..time-format (instant.time value)))) + +(def: (value-format [version time-stamp build]) + (%.Format Value) + (format (text.replace-all ..snapshot + (..time-stamp-format time-stamp) + version) + ..value-separator + (%.nat build))) + +(template [<definition> <tag>] + [(def: <definition> xml.Tag ["" <tag>])] + + [<group> "groupId"] + [<name> "artifactId"] + [<version> "version"] + [<last-updated> "lastUpdated"] + [<metadata> "metadata"] + [<versioning> "versioning"] + [<snapshot> "snapshot"] + [<timestamp> "timestamp"] + [<build-number> "buildNumber"] + [<snapshot-versions> "snapshotVersions"] + [<snapshot-version> "snapshotVersion"] + [<extension> "extension"] + [<value> "value"] + [<updated> "updated"] + ) + +(template [<name> <type> <tag> <pre>] + [(def: <name> + (-> <type> XML) + (|>> <pre> #xml.Text list (#xml.Node <tag> xml.attributes)))] + + [write-group Group ..<group> (|>)] + [write-name Name ..<name> (|>)] + [write-version Version ..<version> (|>)] + [write-last-updated Instant ..<last-updated> ..instant-format] + [write-time-stamp Instant ..<timestamp> ..time-stamp-format] + [write-build-number Nat ..<build-number> %.nat] + [write-extension Type ..<extension> (|>)] + [write-value Value ..<value> ..value-format] + [write-updated Instant ..<updated> ..instant-format] + ) + +(def: (write-snapshot value type) + (-> Value Type XML) + (<| (#xml.Node ..<snapshot-version> xml.attributes) + (list (..write-extension type) + (..write-value value) + (let [[version time-stamp build] value] + (..write-updated time-stamp))))) + +(def: (write-versioning version (^slots [#time-stamp #build #snapshot])) + (-> Version Versioning XML) + (<| (#xml.Node ..<versioning> xml.attributes) + (list (<| (#xml.Node ..<snapshot> xml.attributes) + (list (..write-time-stamp time-stamp) + (..write-build-number build))) + (..write-last-updated time-stamp) + (<| (#xml.Node ..<snapshot-versions> xml.attributes) + (list\map (..write-snapshot [version time-stamp build]) + snapshot))))) + +(def: #export (write (^slots [#group #name #version #versioning])) + (-> Metadata XML) + (#xml.Node ..<metadata> + xml.attributes + (list (..write-group group) + (..write-name name) + (..write-version version) + (..write-versioning version versioning)))) + +(def: (sub tag parser) + (All [a] (-> xml.Tag (Parser a) (Parser a))) + (do <>.monad + [_ (<xml>.node tag)] + (<xml>.children parser))) + +(def: (text tag) + (-> xml.Tag (Parser Text)) + (..sub tag <xml>.text)) + +(def: date-parser + (<text>.Parser Date) + (do <>.monad + [year (<>.codec n.decimal (<text>.exactly 4 <text>.decimal)) + year (<>.lift (year.year (.int year))) + month (<>.codec n.decimal (<text>.exactly 2 <text>.decimal)) + month (<>.lift (month.by-number month)) + day-of-month (<>.codec n.decimal (<text>.exactly 2 <text>.decimal))] + (<>.lift (date.date year month day-of-month)))) + +(def: time-parser + (<text>.Parser Time) + (do <>.monad + [hour (<>.codec n.decimal (<text>.exactly 2 <text>.decimal)) + minute (<>.codec n.decimal (<text>.exactly 2 <text>.decimal)) + second (<>.codec n.decimal (<text>.exactly 2 <text>.decimal))] + (<>.lift (time.time + {#time.hour hour + #time.minute minute + #time.second second + #time.milli-second 0})))) + +(def: last-updated-parser + (Parser Instant) + (<text>.embed (do <>.monad + [date ..date-parser + time ..time-parser] + (wrap (instant.from-date-time date time))) + (..text ..<last-updated>))) + +(def: time-stamp-parser + (Parser Time-Stamp) + (<text>.embed (do <>.monad + [date ..date-parser + _ (<text>.this ..time-stamp-separator) + time ..time-parser] + (wrap (instant.from-date-time date time))) + (..text ..<timestamp>))) + +(def: build-parser + (Parser Build) + (<text>.embed (<>.codec n.decimal + (<text>.many <text>.decimal)) + (..text ..<timestamp>))) + +(exception: #export (time-stamp-mismatch {expected Time-Stamp} {actual Text}) + (exception.report + ["Expected time-stamp" (instant-format expected)] + ["Actual time-stamp" actual])) + +(exception: #export (value-mismatch {expected Value} {actual Text}) + (exception.report + ["Expected" (..value-format expected)] + ["Actual" actual])) + +(def: (snapshot-parser expected) + (-> Value (Parser Type)) + (<| (..sub ..<snapshot-versions>) + (do <>.monad + [#let [[version time-stamp build] expected] + updated (<xml>.somewhere (..text ..<updated>)) + _ (<>.assert (exception.construct ..time-stamp-mismatch [time-stamp updated]) + (\ text.equivalence = (instant-format time-stamp) updated)) + actual (<xml>.somewhere (..text ..<value>)) + _ (<>.assert (exception.construct ..value-mismatch [expected actual]) + (\ text.equivalence = (..value-format expected) actual))] + (<xml>.somewhere (..text ..<extension>))))) + +(def: (versioning-parser version) + (-> Version (Parser Versioning)) + (<| (..sub ..<versioning>) + (do <>.monad + [[time-stamp build] (<| <xml>.somewhere + (..sub ..<snapshot>) + (<>.and ..time-stamp-parser + ..build-parser)) + last-updated (<xml>.somewhere ..last-updated-parser) + _ (<>.assert (exception.construct ..time-stamp-mismatch [time-stamp (instant-format last-updated)]) + (\ instant.equivalence = time-stamp last-updated)) + snapshot (<| <xml>.somewhere + (..sub ..<snapshot-versions>) + (<>.some (..snapshot-parser [version time-stamp build])))] + (wrap {#time-stamp time-stamp + #build build + #snapshot snapshot})))) + +(def: #export parser + (Parser Metadata) + (<| (..sub ..<metadata>) + (do <>.monad + [group (<xml>.somewhere (..text ..<group>)) + name (<xml>.somewhere (..text ..<name>)) + version (<xml>.somewhere (..text ..<version>)) + versioning (<xml>.somewhere (..versioning-parser version))] + (wrap {#group group + #name name + #version version + #versioning versioning})))) + +(def: versioning + (Equivalence Versioning) + ($_ product.equivalence + instant.equivalence + n.equivalence + (list.equivalence text.equivalence) + )) + +(def: #export equivalence + (Equivalence Metadata) + ($_ product.equivalence + text.equivalence + text.equivalence + text.equivalence + ..versioning + )) diff --git a/stdlib/source/test/aedifex/artifact/type.lux b/stdlib/source/test/aedifex/artifact/type.lux index 84807a8c6..5dc1b9caa 100644 --- a/stdlib/source/test/aedifex/artifact/type.lux +++ b/stdlib/source/test/aedifex/artifact/type.lux @@ -11,10 +11,22 @@ ["." set] ["." list]]] [math - ["." random (#+ Random)]]] + ["." random (#+ Random) ("#\." monad)]]] {#program ["." /]}) +(def: #export random + (Random /.Type) + ($_ random.either + ($_ random.either + (random\wrap /.lux-library) + (random\wrap /.jvm-library)) + ($_ random.either + (random\wrap /.pom) + (random\wrap /.md5) + (random\wrap /.sha-1)) + )) + (def: #export test Test (<| (_.covering /._) diff --git a/stdlib/source/test/aedifex/metadata.lux b/stdlib/source/test/aedifex/metadata.lux index 5b8b47b00..6a1ac503a 100644 --- a/stdlib/source/test/aedifex/metadata.lux +++ b/stdlib/source/test/aedifex/metadata.lux @@ -9,6 +9,7 @@ ["." random]]] ["." / #_ ["#." artifact] + ["#." snapshot] [// ["@." artifact]]] {#program @@ -29,4 +30,5 @@ ))) /artifact.test + /snapshot.test ))) diff --git a/stdlib/source/test/aedifex/metadata/snapshot.lux b/stdlib/source/test/aedifex/metadata/snapshot.lux new file mode 100644 index 000000000..e17765038 --- /dev/null +++ b/stdlib/source/test/aedifex/metadata/snapshot.lux @@ -0,0 +1,84 @@ +(.module: + [lux #* + ["_" test (#+ Test)] + [abstract + [monad (#+ do)] + {[0 #spec] + [/ + ["$." equivalence]]}] + [control + ["." try ("#\." functor)] + [parser + ["<.>" xml]]] + [data + [number + ["n" nat]]] + ["." time + ["." date] + ["." year] + ["." month] + ["." instant (#+ Instant)] + ["." duration]] + [math + ["." random (#+ Random)]] + [macro + ["." code]]] + ["$." /// #_ + [artifact + ["#." type]]] + {#program + ["." /]}) + +(def: random-instant + (Random Instant) + (do {! random.monad} + [year (\ ! map (|>> (n.% 10,000) .int) random.nat) + month (\ ! map (n.% 13) random.nat) + day-of-month (\ ! map (n.% 29) random.nat) + hour (\ ! map (n.% 24) random.nat) + minute (\ ! map (n.% 60) random.nat) + second (\ ! map (n.% 60) random.nat)] + (wrap (try.assume + (do try.monad + [year (year.year year) + month (month.by-number month) + date (date.date year month day-of-month) + time (time.time + {#time.hour hour + #time.minute minute + #time.second second + #time.milli-second 0})] + (wrap (instant.from-date-time date time))))))) + +(def: random-versioning + (Random /.Versioning) + ($_ random.and + ..random-instant + random.nat + (random.list 5 $///type.random) + )) + +(def: #export random + (Random /.Metadata) + ($_ random.and + (random.ascii/alpha 5) + (random.ascii/alpha 5) + (random.ascii/alpha 5) + ..random-versioning)) + +(def: #export test + Test + (<| (_.covering /._) + (_.for [/.Metadata]) + ($_ _.and + (_.for [/.equivalence] + ($equivalence.spec /.equivalence ..random)) + (do random.monad + [expected ..random] + (_.cover [/.write /.parser] + (|> expected + /.write + (<xml>.run /.parser) + (try\map (\ /.equivalence = expected)) + (try.default false)))) + ))) diff --git a/stdlib/source/test/lux/control/concurrency/frp.lux b/stdlib/source/test/lux/control/concurrency/frp.lux index 709c756a2..3e0aee4f0 100644 --- a/stdlib/source/test/lux/control/concurrency/frp.lux +++ b/stdlib/source/test/lux/control/concurrency/frp.lux @@ -127,24 +127,20 @@ channel (/.sequential 0 (list\compose inputs inputs))] _ (promise.future (/.subscribe (function (_ value) (do {! io.monad} - [current (atom.read sink)] - (if (n.< (list.size inputs) - (row.size current)) - (do ! - [_ (atom.update (row.add value) sink)] - (wrap (#.Some []))) - (wrap (#.Some []))))) + [current (atom.read sink) + _ (atom.update (row.add value) sink)] + (wrap (if (n.< (list.size inputs) + (inc (row.size current))) + (#.Some []) + #.None)))) channel)) - output (/.consume channel) + _ (/.consume channel) listened (|> sink atom.read promise.future (\ ! map row.to-list))] (_.cover' [/.Subscriber /.subscribe] - (and (list\= inputs - output) - (list\= output - listened))))) + (list\= inputs listened)))) (wrap (do promise.monad [actual (/.fold (function (_ input total) (promise.resolved (n.+ input total))) @@ -173,9 +169,9 @@ (_.cover' [/.distinct] (list\= (list distint/0 distint/1 distint/2) actual)))) - (let [polling-delay 10 - wiggle-room (n.* 5 polling-delay) + (let [polling-delay 1 amount-of-polls 5 + wiggle-room ($_ n.* amount-of-polls 2 polling-delay) total-delay (|> polling-delay (n.* amount-of-polls) (n.+ wiggle-room))] diff --git a/stdlib/source/test/lux/control/parser/text.lux b/stdlib/source/test/lux/control/parser/text.lux index 5a2245401..7c1f5d932 100644 --- a/stdlib/source/test/lux/control/parser/text.lux +++ b/stdlib/source/test/lux/control/parser/text.lux @@ -10,8 +10,9 @@ [data ["." maybe] ["." text ("#\." equivalence) - ["." unicode] - ["%" format (#+ format)]] + ["%" format (#+ format)] + ["." unicode + ["#/." segment]]] [number ["n" nat]] [collection @@ -81,41 +82,41 @@ (..should-fail out-of-range (/.range offset limit))))) (do {! random.monad} [expected (random.char unicode.ascii/upper-alpha) - invalid (random.filter (|>> (unicode.within? unicode.basic-latin/upper-alpha) not) + invalid (random.filter (|>> (unicode/segment.within? unicode/segment.basic-latin/upper-alpha) not) (random.char unicode.full))] (_.cover [/.upper] (and (..should-pass (text.from-code expected) /.upper) (..should-fail (text.from-code invalid) /.upper)))) (do {! random.monad} [expected (random.char unicode.ascii/lower-alpha) - invalid (random.filter (|>> (unicode.within? unicode.basic-latin/lower-alpha) not) + invalid (random.filter (|>> (unicode/segment.within? unicode/segment.basic-latin/lower-alpha) not) (random.char unicode.full))] (_.cover [/.lower] (and (..should-pass (text.from-code expected) /.lower) (..should-fail (text.from-code invalid) /.lower)))) (do {! random.monad} [expected (\ ! map (n.% 10) random.nat) - invalid (random.char (unicode.set [unicode.number-forms (list)]))] + invalid (random.char (unicode.set [unicode/segment.number-forms (list)]))] (_.cover [/.decimal] (and (..should-pass (\ n.decimal encode expected) /.decimal) (..should-fail (text.from-code invalid) /.decimal)))) (do {! random.monad} [expected (\ ! map (n.% 8) random.nat) - invalid (random.char (unicode.set [unicode.number-forms (list)]))] + invalid (random.char (unicode.set [unicode/segment.number-forms (list)]))] (_.cover [/.octal] (and (..should-pass (\ n.octal encode expected) /.octal) (..should-fail (text.from-code invalid) /.octal)))) (do {! random.monad} [expected (\ ! map (n.% 16) random.nat) - invalid (random.char (unicode.set [unicode.number-forms (list)]))] + invalid (random.char (unicode.set [unicode/segment.number-forms (list)]))] (_.cover [/.hexadecimal] (and (..should-pass (\ n.hex encode expected) /.hexadecimal) (..should-fail (text.from-code invalid) /.hexadecimal)))) (do {! random.monad} [expected (random.char unicode.ascii/alpha) invalid (random.filter (function (_ char) - (not (or (unicode.within? unicode.basic-latin/upper-alpha char) - (unicode.within? unicode.basic-latin/lower-alpha char)))) + (not (or (unicode/segment.within? unicode/segment.basic-latin/upper-alpha char) + (unicode/segment.within? unicode/segment.basic-latin/lower-alpha char)))) (random.char unicode.full))] (_.cover [/.alpha] (and (..should-pass (text.from-code expected) /.alpha) @@ -123,9 +124,9 @@ (do {! random.monad} [expected (random.char unicode.ascii/alpha-num) invalid (random.filter (function (_ char) - (not (or (unicode.within? unicode.basic-latin/upper-alpha char) - (unicode.within? unicode.basic-latin/lower-alpha char) - (unicode.within? unicode.basic-latin/decimal char)))) + (not (or (unicode/segment.within? unicode/segment.basic-latin/upper-alpha char) + (unicode/segment.within? unicode/segment.basic-latin/lower-alpha char) + (unicode/segment.within? unicode/segment.basic-latin/decimal char)))) (random.char unicode.full))] (_.cover [/.alpha-num] (and (..should-pass (text.from-code expected) /.alpha-num) @@ -394,7 +395,7 @@ (text\= expected actual)))))) (do {! random.monad} [invalid (random.ascii/upper-alpha 1) - expected (random.filter (|>> (unicode.within? unicode.basic-latin/upper-alpha) + expected (random.filter (|>> (unicode/segment.within? unicode/segment.basic-latin/upper-alpha) not) (random.char unicode.full)) #let [upper! (/.one-of! "ABCDEFGHIJKLMNOPQRSTUVWXYZ")]] @@ -414,8 +415,8 @@ [upper (random.ascii/upper-alpha 1) lower (random.ascii/lower-alpha 1) invalid (random.filter (function (_ char) - (not (or (unicode.within? unicode.basic-latin/upper-alpha char) - (unicode.within? unicode.basic-latin/lower-alpha char)))) + (not (or (unicode/segment.within? unicode/segment.basic-latin/upper-alpha char) + (unicode/segment.within? unicode/segment.basic-latin/lower-alpha char)))) (random.char unicode.full)) #let [upper! (/.one-of! "ABCDEFGHIJKLMNOPQRSTUVWXYZ") lower! (/.one-of! "abcdefghijklmnopqrstuvwxyz")]] diff --git a/stdlib/source/test/lux/data/collection/tree/finger.lux b/stdlib/source/test/lux/data/collection/tree/finger.lux index 3760298f9..3c1325d4e 100644 --- a/stdlib/source/test/lux/data/collection/tree/finger.lux +++ b/stdlib/source/test/lux/data/collection/tree/finger.lux @@ -7,7 +7,9 @@ ["." maybe ("#\." functor)] ["." text ("#\." equivalence monoid)] [number - ["n" nat]]] + ["n" nat]] + [collection + ["." list ("#\." fold)]]] [math ["." random]] [type (#+ :by-example)]] @@ -73,6 +75,20 @@ (/.value (\ ..builder branch (\ ..builder leaf tag-left expected-left) (\ ..builder leaf tag-right expected-right)))))) + (do random.monad + [#let [tags-equivalence (list.equivalence text.equivalence) + values-equivalence (list.equivalence n.equivalence)] + tags/H (random.ascii/alpha-num 1) + tags/T (random.list 5 (random.ascii/alpha-num 1)) + values/H random.nat + values/T (random.list 5 random.nat)] + (_.cover [/.tags /.values] + (let [tree (list\fold (function (_ [tag value] tree) + (\ builder branch tree (\ builder leaf tag value))) + (\ builder leaf tags/H values/H) + (list.zip/2 tags/T values/T))] + (and (\ tags-equivalence = (list& tags/H tags/T) (/.tags tree)) + (\ values-equivalence = (list& values/H values/T) (/.values tree)))))) (_.cover [/.search] (let [can-find-correct-one! (|> (\ ..builder leaf tag-left expected-left) diff --git a/stdlib/source/test/lux/data/format/tar.lux b/stdlib/source/test/lux/data/format/tar.lux index f837c0d18..73ccec27f 100644 --- a/stdlib/source/test/lux/data/format/tar.lux +++ b/stdlib/source/test/lux/data/format/tar.lux @@ -13,9 +13,10 @@ ["." maybe] ["." binary ("#\." equivalence)] ["." text ("#\." equivalence) + ["%" format (#+ format)] ["." encoding] - ["." unicode] - ["%" format (#+ format)]] + ["." unicode + ["#/." segment]]] [number ["n" nat] ["i" int]] @@ -38,7 +39,7 @@ (do {! random.monad} [expected (random.ascii/lower-alpha /.path-size) invalid (random.ascii/lower-alpha (inc /.path-size)) - not-ascii (random.text (random.char (unicode.set [unicode.katakana (list)])) + not-ascii (random.text (random.char (unicode.set [unicode/segment.katakana (list)])) /.path-size)] (`` ($_ _.and (_.cover [/.path /.from-path] @@ -71,7 +72,7 @@ (do {! random.monad} [expected (random.ascii/lower-alpha /.name-size) invalid (random.ascii/lower-alpha (inc /.name-size)) - not-ascii (random.text (random.char (unicode.set [unicode.katakana (list)])) + not-ascii (random.text (random.char (unicode.set [unicode/segment.katakana (list)])) /.name-size)] (`` ($_ _.and (_.cover [/.name /.from-name] @@ -312,7 +313,7 @@ [path (random.ascii/lower-alpha /.path-size) expected (random.ascii/lower-alpha /.name-size) invalid (random.ascii/lower-alpha (inc /.name-size)) - not-ascii (random.text (random.char (unicode.set [unicode.katakana (list)])) + not-ascii (random.text (random.char (unicode.set [unicode/segment.katakana (list)])) /.name-size)] (_.for [/.Ownership /.Owner /.ID] ($_ _.and diff --git a/stdlib/source/test/lux/data/text.lux b/stdlib/source/test/lux/data/text.lux index 2cf0e2cfd..b9dfdb1a9 100644 --- a/stdlib/source/test/lux/data/text.lux +++ b/stdlib/source/test/lux/data/text.lux @@ -23,7 +23,8 @@ ["#." buffer] ["#." encoding] ["#." format] - ["#." regex]] + ["#." regex] + ["#." unicode]] {1 ["." /]}) @@ -302,4 +303,5 @@ /encoding.test /format.test /regex.test + /unicode.test ))) diff --git a/stdlib/source/test/lux/data/text/regex.lux b/stdlib/source/test/lux/data/text/regex.lux index 83d2cfcc4..f72c19030 100644 --- a/stdlib/source/test/lux/data/text/regex.lux +++ b/stdlib/source/test/lux/data/text/regex.lux @@ -1,8 +1,8 @@ (.module: [lux #* - ["%" data/text/format (#+ format)] ["_" test (#+ Test)] - [abstract/monad (#+ do)] + [abstract + [monad (#+ do)]] [control pipe ["." try] @@ -11,9 +11,10 @@ ["s" code]]] [data [number (#+ hex)] - ["." text ("#\." equivalence)]] + ["." text ("#\." equivalence) + ["%" format (#+ format)]]] [math - ["r" random]] + ["." random]] ["." meta] [macro [syntax (#+ syntax:)]]] @@ -57,13 +58,8 @@ (case> (^ (#try.Success (~ pattern))) true - (#try.Failure (~ g!message)) - (exec (log! (format "{{{Failure}}} " (~ g!message))) - false) - (~ g!_) - (exec (log! (format "{{{Success}}} " "OH NO")) - false)))))))) + false))))))) (def: basics Test @@ -273,36 +269,34 @@ "123-456-7890"))) )) -(def: pattern-matching - Test - (do r.monad - [sample1 (r.unicode 3) - sample2 (r.unicode 3) - sample3 (r.unicode 4)] - (case (format sample1 "-" sample2 "-" sample3) - (/.^regex "(.{3})-(.{3})-(.{4})" - [_ match1 match2 match3]) - (_.test "Can pattern-match using regular-expressions." - (and (text\= sample1 match1) - (text\= sample2 match2) - (text\= sample3 match3))) - - _ - (_.test "Cannot pattern-match using regular-expressions." - #0)))) - (def: #export test Test - (<| (_.context (%.name (name-of /.regex))) + (<| (_.covering /._) ($_ _.and - ..basics - ..system-character-classes - ..special-system-character-classes - ..custom-character-classes - ..references - ..fuzzy-quantifiers - ..crisp-quantifiers - ..groups - ..alternation - ..pattern-matching + (_.for [/.regex] + ($_ _.and + ..basics + ..system-character-classes + ..special-system-character-classes + ..custom-character-classes + ..references + ..fuzzy-quantifiers + ..crisp-quantifiers + ..groups + ..alternation + )) + (do random.monad + [sample1 (random.unicode 3) + sample2 (random.unicode 3) + sample3 (random.unicode 4)] + (_.cover [/.^regex] + (case (format sample1 "-" sample2 "-" sample3) + (/.^regex "(.{3})-(.{3})-(.{4})" + [_ match1 match2 match3]) + (and (text\= sample1 match1) + (text\= sample2 match2) + (text\= sample3 match3)) + + _ + false))) ))) diff --git a/stdlib/source/test/lux/data/text/unicode.lux b/stdlib/source/test/lux/data/text/unicode.lux new file mode 100644 index 000000000..1b47c8cdb --- /dev/null +++ b/stdlib/source/test/lux/data/text/unicode.lux @@ -0,0 +1,91 @@ +(.module: + [lux #* + ["_" test (#+ Test)] + [abstract + [monad (#+ do)] + {[0 #spec] + [/ + ["$." equivalence]]}] + [data + ["." product] + ["." bit ("#\." equivalence)] + [number + ["n" nat]] + [collection + ["." set ("#\." equivalence)]]] + [math + ["." random (#+ Random)]]] + ["." / #_ + ["#." segment]] + {1 + ["." / + ["." segment]]}) + +(def: #export random + (Random /.Set) + (do {! random.monad} + [left /segment.random + right /segment.random] + (wrap (/.set [left (list right)])))) + +(def: #export test + Test + (<| (_.covering /._) + (_.for [/.Set]) + (do {! random.monad} + [segment /segment.random + inside (\ ! map + (|>> (n.% (segment.size segment)) + (n.+ (segment.start segment))) + random.nat) + left /segment.random + right /segment.random + #let [equivalence (product.equivalence n.equivalence + n.equivalence)]] + (`` ($_ _.and + (_.for [/.equivalence] + ($equivalence.spec /.equivalence ..random)) + + (_.cover [/.range] + (let [[start end] (/.range (/.set [left (list right)]))] + (and (n.= (n.min (segment.start left) + (segment.start right)) + start) + (n.= (n.max (segment.end left) + (segment.end right)) + end)))) + (_.cover [/.member?] + (bit\= (segment.within? segment inside) + (/.member? (/.set [segment (list)]) inside))) + (_.cover [/.compose] + (\ equivalence = + [(n.min (segment.start left) + (segment.start right)) + (n.max (segment.end left) + (segment.end right))] + (/.range (/.compose (/.set [left (list)]) + (/.set [right (list)]))))) + (_.cover [/.set] + (\ equivalence = + (/.range (/.compose (/.set [left (list)]) + (/.set [right (list)]))) + (/.range (/.set [left (list right)])))) + (~~ (template [<set>] + [(do random.monad + [char (random.char <set>) + #let [[start end] (/.range <set>)]] + (_.cover [<set>] + (and (/.member? <set> char) + (not (/.member? <set> (dec start))) + (not (/.member? <set> (inc end))))))] + + [/.ascii] + [/.ascii/alpha] + [/.ascii/alpha-num] + [/.ascii/lower-alpha] + [/.ascii/upper-alpha] + [/.full] + )) + + /segment.test + ))))) diff --git a/stdlib/source/test/lux/data/text/unicode/segment.lux b/stdlib/source/test/lux/data/text/unicode/segment.lux new file mode 100644 index 000000000..62a399cd1 --- /dev/null +++ b/stdlib/source/test/lux/data/text/unicode/segment.lux @@ -0,0 +1,211 @@ +(.module: + [lux #* + ["_" test (#+ Test)] + [abstract + [monad (#+ do)] + {[0 #spec] + [/ + ["$." equivalence] + ["$." hash] + ["$." monoid]]}] + [data + ["." text] + [number (#+ hex) + ["n" nat]] + [collection + ["." set] + ["." list]]] + [macro + ["." template]] + [math + ["." random (#+ Random)]]] + {1 + ["." /]}) + +(def: #export random + (Random /.Segment) + (do random.monad + [start random.nat + end random.nat] + (wrap (/.segment start end)))) + +(with-expansions [<segments> (as-is [segments/0 + [/.basic-latin + /.latin-1-supplement + /.latin-extended-a + /.latin-extended-b + /.ipa-extensions + /.spacing-modifier-letters + /.combining-diacritical-marks + /.greek-and-coptic + /.cyrillic + /.cyrillic-supplementary + /.armenian + /.hebrew + /.arabic + /.syriac + /.thaana + /.devanagari + /.bengali + /.gurmukhi + /.gujarati + /.oriya + /.tamil + /.telugu + /.kannada + /.malayalam + /.sinhala + /.thai + /.lao + /.tibetan + /.myanmar + /.georgian + /.hangul-jamo + /.ethiopic + /.cherokee + /.unified-canadian-aboriginal-syllabics + /.ogham + /.runic + /.tagalog + /.hanunoo + /.buhid + /.tagbanwa + /.khmer + /.mongolian]] + [segments/1 + [/.limbu + /.tai-le + /.khmer-symbols + /.phonetic-extensions + /.latin-extended-additional + /.greek-extended + /.general-punctuation + /.superscripts-and-subscripts + /.currency-symbols + /.combining-diacritical-marks-for-symbols + /.letterlike-symbols + /.number-forms + /.arrows + /.mathematical-operators + /.miscellaneous-technical + /.control-pictures + /.optical-character-recognition + /.enclosed-alphanumerics + /.box-drawing + /.block-elements + /.geometric-shapes + /.miscellaneous-symbols + /.dingbats + /.miscellaneous-mathematical-symbols-a + /.supplemental-arrows-a + /.braille-patterns + /.supplemental-arrows-b + /.miscellaneous-mathematical-symbols-b + /.supplemental-mathematical-operators + /.miscellaneous-symbols-and-arrows + /.cjk-radicals-supplement + /.kangxi-radicals + /.ideographic-description-characters + /.cjk-symbols-and-punctuation + /.hiragana + /.katakana + /.bopomofo + /.hangul-compatibility-jamo + /.kanbun + /.bopomofo-extended + /.katakana-phonetic-extensions + /.enclosed-cjk-letters-and-months + /.cjk-compatibility + /.cjk-unified-ideographs-extension-a + /.yijing-hexagram-symbols + /.cjk-unified-ideographs + /.yi-syllables + /.yi-radicals + /.hangul-syllables + /.high-surrogates + /.high-private-use-surrogates + /.low-surrogates + /.private-use-area + /.cjk-compatibility-ideographs + /.alphabetic-presentation-forms]] + [segments/2 + [/.arabic-presentation-forms-a + /.variation-selectors + /.combining-half-marks + /.cjk-compatibility-forms + /.small-form-variants + /.arabic-presentation-forms-b + /.halfwidth-and-fullwidth-forms + /.specials + + ## Specialized segments + /.basic-latin/decimal + /.basic-latin/upper-alpha + /.basic-latin/lower-alpha]] + ) + <named> (template [<definition> <part>] + [((: (-> Any (List /.Segment)) + (function (_ _) + (`` (list (~~ (template.splice <part>)))))) + [])] + + <segments>)] + (template [<definition> <part>] + [(def: <definition> + Test + (`` (_.cover [(~~ (template.splice <part>))] + (let [all (list.concat (list <named>)) + unique (set.from-list /.hash all)] + (n.= (list.size all) + (set.size unique))))))] + + <segments> + ) + + (def: #export test + Test + (<| (_.covering /._) + (_.for [/.Segment]) + (do {! random.monad} + [#let [top-start (hex "AC00") + top-end (hex "D7AF")] + start (\ ! map (|>> (n.% top-start) inc) random.nat) + end (\ ! map (|>> (n.% top-end) inc) random.nat) + #let [sample (/.segment start end) + size (/.size sample)] + inside (\ ! map + (|>> (n.% size) + (n.+ (/.start sample))) + random.nat)] + (`` ($_ _.and + (_.for [/.equivalence] + ($equivalence.spec /.equivalence ..random)) + (_.for [/.hash] + ($hash.spec /.hash ..random)) + (_.for [/.monoid] + ($monoid.spec /.equivalence /.monoid ..random)) + + (_.cover [/.segment] + (\ /.equivalence = + (/.segment start end) + (/.segment end start))) + (_.cover [/.start] + (n.= (n.min start end) + (/.start (/.segment start end)))) + (_.cover [/.end] + (n.= (n.max start end) + (/.end (/.segment start end)))) + (_.cover [/.size] + (n.= (inc (n.- (n.min start end) + (n.max start end))) + (/.size (/.segment start end)))) + (_.cover [/.within?] + (and (/.within? sample inside) + (not (/.within? sample (dec (/.start sample)))) + (not (/.within? sample (inc (/.end sample)))))) + (~~ (template [<definition> <part>] + [<definition>] + + <segments>)) + ))))) + ) |