├── .gitignore ├── README.md ├── src ├── Utils.elm └── Random │ ├── Order.elm │ ├── List.elm │ ├── Int.elm │ ├── Maybe.elm │ ├── Dict.elm │ ├── Result.elm │ ├── Color.elm │ ├── Date.elm │ ├── Set.elm │ ├── Float.elm │ ├── Array.elm │ ├── String.elm │ ├── Extra.elm │ └── Char.elm └── elm-package.json /.gitignore: -------------------------------------------------------------------------------- 1 | elm-stuff 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # elm-random-extra 2 | 3 | **DEPRECATED:** Please use [elm-community/random-extra](http://package.elm-lang.org/packages/elm-community/random-extra/latest) instead. 4 | 5 | Extra functionality for the core Random library 6 | -------------------------------------------------------------------------------- /src/Utils.elm: -------------------------------------------------------------------------------- 1 | module Utils exposing (..) 2 | 3 | import List exposing (drop) 4 | 5 | 6 | get : Int -> List a -> Maybe a 7 | get index list = 8 | if index < 0 then 9 | Nothing 10 | else 11 | case List.drop index list of 12 | [] -> 13 | Nothing 14 | 15 | x :: xs -> 16 | Just x 17 | -------------------------------------------------------------------------------- /src/Random/Order.elm: -------------------------------------------------------------------------------- 1 | module Random.Order exposing (..) 2 | 3 | {-| List of Order Generators 4 | 5 | # Generators 6 | @docs order 7 | -} 8 | 9 | import Random exposing (Generator) 10 | import Random.Extra exposing (selectWithDefault) 11 | 12 | 13 | {-| Generate a random order with equal probability. 14 | -} 15 | order : Generator Order 16 | order = 17 | selectWithDefault EQ 18 | [ LT 19 | , EQ 20 | , GT 21 | ] 22 | -------------------------------------------------------------------------------- /src/Random/List.elm: -------------------------------------------------------------------------------- 1 | module Random.List exposing (..) 2 | 3 | {-| List of List Generators 4 | 5 | # Generators 6 | @docs emptyList, rangeLengthList 7 | 8 | -} 9 | 10 | import Random exposing (Generator, int, list) 11 | import Random.Extra exposing (flatMap, constant) 12 | 13 | 14 | {-| Generator that always returns the empty list. 15 | -} 16 | emptyList : Generator (List a) 17 | emptyList = 18 | constant [] 19 | 20 | 21 | {-| Generate a random list of random length given a minimum length and 22 | a maximum length. 23 | -} 24 | rangeLengthList : Int -> Int -> Generator a -> Generator (List a) 25 | rangeLengthList minLength maxLength generator = 26 | flatMap (\len -> list len generator) (int minLength maxLength) 27 | -------------------------------------------------------------------------------- /elm-package.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "1.0.2", 3 | "summary": "[DEPRECATED] Extra functionality for the core Random library", 4 | "repository": "https://github.com/elm-community/elm-random-extra.git", 5 | "license": "MIT", 6 | "source-directories": [ 7 | "src" 8 | ], 9 | "exposed-modules": [ 10 | "Random.Array", 11 | "Random.Char", 12 | "Random.Color", 13 | "Random.Date", 14 | "Random.Dict", 15 | "Random.Extra", 16 | "Random.Float", 17 | "Random.Int", 18 | "Random.List", 19 | "Random.Maybe", 20 | "Random.Order", 21 | "Random.Result", 22 | "Random.Set", 23 | "Random.String" 24 | ], 25 | "dependencies": { 26 | "elm-lang/core": "4.0.0 <= v < 5.0.0" 27 | }, 28 | "elm-version": "0.17.0 <= v < 0.18.0" 29 | } -------------------------------------------------------------------------------- /src/Random/Int.elm: -------------------------------------------------------------------------------- 1 | module Random.Int exposing (..) 2 | 3 | {-| List of Int Generators 4 | 5 | # Generators 6 | @docs anyInt, positiveInt, negativeInt, intGreaterThan, intLessThan 7 | -} 8 | 9 | import Random exposing (Generator, int, minInt, maxInt) 10 | 11 | 12 | {-| Generator that generates any int that can be generate by the 13 | random generator algorithm. 14 | -} 15 | anyInt : Generator Int 16 | anyInt = 17 | int minInt maxInt 18 | 19 | 20 | {-| Generator that generates a positive int 21 | -} 22 | positiveInt : Generator Int 23 | positiveInt = 24 | int 1 maxInt 25 | 26 | 27 | {-| Generator that generates a negative int 28 | -} 29 | negativeInt : Generator Int 30 | negativeInt = 31 | int minInt -1 32 | 33 | 34 | {-| Generator that generates an int greater than a given int 35 | -} 36 | intGreaterThan : Int -> Generator Int 37 | intGreaterThan value = 38 | int (value + 1) maxInt 39 | 40 | 41 | {-| Generator that generates an int less than a given int 42 | -} 43 | intLessThan : Int -> Generator Int 44 | intLessThan value = 45 | int minInt (value - 1) 46 | -------------------------------------------------------------------------------- /src/Random/Maybe.elm: -------------------------------------------------------------------------------- 1 | module Random.Maybe exposing (..) 2 | 3 | {-| List of Maybe Generators 4 | 5 | # Generators 6 | @docs maybe, withDefault, withDefaultGenerator 7 | 8 | -} 9 | 10 | import Random exposing (Generator, map) 11 | import Random.Extra exposing (constant, frequency, flatMap) 12 | import Maybe 13 | 14 | 15 | {-| Generate a Maybe from a generator. Will generate Nothings 50% of the time. 16 | -} 17 | maybe : Generator a -> Generator (Maybe a) 18 | maybe generator = 19 | frequency 20 | [ ( 1, constant Nothing ) 21 | , ( 1, map Just generator ) 22 | ] 23 | (constant Nothing) 24 | 25 | 26 | {-| Generate values from a maybe generator or a default value. 27 | -} 28 | withDefault : a -> Generator (Maybe a) -> Generator a 29 | withDefault value generator = 30 | map (Maybe.withDefault value) generator 31 | 32 | 33 | {-| Generate values from a maybe generator or a default generator. 34 | -} 35 | withDefaultGenerator : Generator a -> Generator (Maybe a) -> Generator a 36 | withDefaultGenerator default generator = 37 | flatMap (flip withDefault generator) default 38 | -------------------------------------------------------------------------------- /src/Random/Dict.elm: -------------------------------------------------------------------------------- 1 | module Random.Dict exposing (..) 2 | 3 | {-| List of Dict Generators 4 | 5 | # Generators 6 | @docs dict, emptyDict, rangeLengthDict 7 | 8 | -} 9 | 10 | import Dict exposing (Dict, fromList, empty) 11 | import Random exposing (Generator, map, list, int) 12 | import Random.Extra exposing (zip, flatMap, constant) 13 | 14 | 15 | {-| Generate a random dict with given length, key generator, and value generator 16 | 17 | randomLength10StringIntDict = dict 10 (englishWord 10) (int 0 100) 18 | -} 19 | dict : Int -> Generator comparable -> Generator value -> Generator (Dict comparable value) 20 | dict dictLength keyGenerator valueGenerator = 21 | map (fromList) (list dictLength (zip keyGenerator valueGenerator)) 22 | 23 | 24 | {-| Generator that always generates the empty dict 25 | -} 26 | emptyDict : Generator (Dict comparable value) 27 | emptyDict = 28 | constant empty 29 | 30 | 31 | {-| Generate a random dict of random length given a minimum length and 32 | a maximum length. 33 | -} 34 | rangeLengthDict : Int -> Int -> Generator comparable -> Generator value -> Generator (Dict comparable value) 35 | rangeLengthDict minLength maxLength keyGenerator valueGenerator = 36 | flatMap (\len -> dict len keyGenerator valueGenerator) (int minLength maxLength) 37 | -------------------------------------------------------------------------------- /src/Random/Result.elm: -------------------------------------------------------------------------------- 1 | module Random.Result exposing (..) 2 | 3 | {-| List of Result Generators 4 | 5 | # Generators 6 | @docs ok, error, result 7 | 8 | -} 9 | 10 | import Random exposing (Generator, generate, map, float) 11 | import Random.Extra exposing (frequency) 12 | 13 | 14 | {-| Generate an ok result from a random generator of values 15 | -} 16 | ok : Generator value -> Generator (Result error value) 17 | ok generator = 18 | map Ok generator 19 | 20 | 21 | {-| Generate an error result from a random generator of errors 22 | -} 23 | error : Generator error -> Generator (Result error value) 24 | error generator = 25 | map Err generator 26 | 27 | 28 | {-| Generate an ok result or an error result with 50-50 chance 29 | 30 | This is simply implemented as follows: 31 | 32 | result errorGenerator okGenerator = 33 | frequency 34 | [ (1, error errorGenerator) 35 | , (1, ok okGenerator) 36 | ] (ok okGenerator) 37 | 38 | If you want to generate results with a different frequency, tweak those 39 | numbers to your bidding in your own custom generators. 40 | -} 41 | result : Generator error -> Generator value -> Generator (Result error value) 42 | result errorGenerator okGenerator = 43 | frequency 44 | [ ( 1, error errorGenerator ) 45 | , ( 1, ok okGenerator ) 46 | ] 47 | (ok okGenerator) 48 | -------------------------------------------------------------------------------- /src/Random/Color.elm: -------------------------------------------------------------------------------- 1 | module Random.Color exposing (..) 2 | 3 | {-| List of Color Generators 4 | 5 | # Generators 6 | @docs rgb, rgba, hsl, hsla, greyscale, grayscale, red, green, blue 7 | 8 | -} 9 | 10 | import Color exposing (Color) 11 | import Random exposing (Generator, map, map3, map4, int, float) 12 | 13 | 14 | {-| Generate a random non-transparent color by random RGB values. 15 | -} 16 | rgb : Generator Color 17 | rgb = 18 | map3 Color.rgb (int 0 255) (int 0 255) (int 0 255) 19 | 20 | 21 | {-| Generate a random transparent color by random RGBA values. 22 | -} 23 | rgba : Generator Color 24 | rgba = 25 | map4 Color.rgba (int 0 255) (int 0 255) (int 0 255) (float 0 1) 26 | 27 | 28 | {-| Generate a random non-transparent color by random HSL values. 29 | -} 30 | hsl : Generator Color 31 | hsl = 32 | map3 Color.hsl (map degrees (float 0 360)) (float 0 1) (float 0 1) 33 | 34 | 35 | {-| Generate a random transparent color by random HSLA values. 36 | -} 37 | hsla : Generator Color 38 | hsla = 39 | map4 Color.hsla (map degrees (float 0 360)) (float 0 1) (float 0 1) (float 0 1) 40 | 41 | 42 | {-| Generate a random shade of grey 43 | -} 44 | greyscale : Generator Color 45 | greyscale = 46 | map Color.greyscale (float 0 1) 47 | 48 | 49 | {-| Alias for greyscale 50 | -} 51 | grayscale : Generator Color 52 | grayscale = 53 | greyscale 54 | 55 | 56 | {-| Generate a random shade of red. 57 | -} 58 | red : Generator Color 59 | red = 60 | map (\red -> Color.rgb red 0 0) (int 0 255) 61 | 62 | 63 | {-| Generate a random shade of green. 64 | -} 65 | green : Generator Color 66 | green = 67 | map (\green -> Color.rgb 0 green 0) (int 0 255) 68 | 69 | 70 | {-| Generate a random shade of blue. 71 | -} 72 | blue : Generator Color 73 | blue = 74 | map (\blue -> Color.rgb 0 0 blue) (int 0 255) 75 | -------------------------------------------------------------------------------- /src/Random/Date.elm: -------------------------------------------------------------------------------- 1 | module Random.Date exposing (..) 2 | 3 | {-| List of date Generators 4 | 5 | # Generators 6 | @docs date, day, month, year, hour, hour24, hour12, minute, second 7 | 8 | -} 9 | 10 | import Date exposing (Day(..), Month(..), fromTime, toTime, Date) 11 | import Time exposing (Time) 12 | import Random exposing (Generator, map, int, float) 13 | import Random.Extra exposing (selectWithDefault) 14 | 15 | 16 | {-| Generate a random day of the week. 17 | -} 18 | day : Generator Day 19 | day = 20 | selectWithDefault Mon 21 | [ Mon 22 | , Tue 23 | , Wed 24 | , Thu 25 | , Fri 26 | , Sat 27 | , Sun 28 | ] 29 | 30 | 31 | {-| Generate a random month of the year. 32 | -} 33 | month : Generator Month 34 | month = 35 | selectWithDefault Jan 36 | [ Jan 37 | , Feb 38 | , Mar 39 | , Apr 40 | , May 41 | , Jun 42 | , Jul 43 | , Aug 44 | , Sep 45 | , Oct 46 | , Nov 47 | , Dec 48 | ] 49 | 50 | 51 | {-| Generate a random year given a start year and end year (alias for `int`) 52 | -} 53 | year : Int -> Int -> Generator Int 54 | year = 55 | int 56 | 57 | 58 | {-| Generate a random hour (random int between 0 and 23 inclusive) 59 | -} 60 | hour : Generator Int 61 | hour = 62 | int 0 23 63 | 64 | 65 | {-| Generate a random 24-hour day hour (random int between 0 and 23 inclusive) 66 | -} 67 | hour24 : Generator Int 68 | hour24 = 69 | int 0 23 70 | 71 | 72 | {-| Generate a random 12-hour day hour (random int between 0 and 11 inclusive) 73 | -} 74 | hour12 : Generator Int 75 | hour12 = 76 | int 0 11 77 | 78 | 79 | {-| Generate a random minute (random int between 0 and 59 inclusive) 80 | -} 81 | minute : Generator Int 82 | minute = 83 | int 0 59 84 | 85 | 86 | {-| Generate a random second (random int between 0 and 59 inclusive) 87 | -} 88 | second : Generator Int 89 | second = 90 | int 0 59 91 | 92 | 93 | {-| Generate a random date given a start date and an end date. 94 | -} 95 | date : Date -> Date -> Generator Date 96 | date startDate endDate = 97 | map fromTime (float (toTime startDate) (toTime endDate)) 98 | -------------------------------------------------------------------------------- /src/Random/Set.elm: -------------------------------------------------------------------------------- 1 | module Random.Set exposing (..) 2 | 3 | {-| List of Random Set Generators 4 | 5 | # Generators 6 | @docs empty, singleton, set, notInSet 7 | 8 | # Combinators 9 | @docs select, selectWithDefault 10 | 11 | -} 12 | 13 | import Set exposing (Set) 14 | import Random exposing (Generator, map, andThen) 15 | import Random.Extra exposing (constant, dropIf, keepIf) 16 | 17 | 18 | {-| Generator that always returns the empty set 19 | -} 20 | empty : Generator (Set comparable) 21 | empty = 22 | constant Set.empty 23 | 24 | 25 | {-| Generator that creates a singleton set from a generator 26 | -} 27 | singleton : Generator comparable -> Generator (Set comparable) 28 | singleton generator = 29 | map Set.singleton generator 30 | 31 | 32 | {-| Filter a generator of all values not in a given set. 33 | -} 34 | notInSet : Set comparable -> Generator comparable -> Generator comparable 35 | notInSet set generator = 36 | dropIf (flip Set.member set) generator 37 | 38 | 39 | {-| Select a value from a set uniformly at random, or `Nothing` for an empty set. 40 | Analogous to `Random.Extra.select` but with sets. 41 | -} 42 | select : Set comparable -> Generator (Maybe comparable) 43 | select set = 44 | Random.Extra.select (Set.toList set) 45 | 46 | 47 | {-| Select a value from a set uniformly at random, with a default. 48 | Analogous to `Random.Extra.selectWithDefault` but with sets. 49 | -} 50 | selectWithDefault : comparable -> Set comparable -> Generator comparable 51 | selectWithDefault default set = 52 | Random.Extra.selectWithDefault default (Set.toList set) 53 | 54 | 55 | {-| Generate a set of at most the given size from a generator. 56 | 57 | The size of a generated set is limited both by the integer provided and the 58 | number of unique values the generator can produce. It is very likely, but not 59 | guaranteed, that generated sets will be as big as the smaller of these two limits. 60 | -} 61 | set : Int -> Generator comparable -> Generator (Set comparable) 62 | set maxLength generator = 63 | let 64 | helper set remaining strikes = 65 | if remaining <= 0 || strikes == 10 then 66 | constant set 67 | else 68 | generator 69 | `andThen` \val -> 70 | let 71 | newSet = 72 | Set.insert val set 73 | in 74 | if Set.size newSet == Set.size set then 75 | helper set remaining (strikes + 1) 76 | else 77 | helper newSet (remaining - 1) 0 78 | in 79 | helper Set.empty maxLength 0 80 | -------------------------------------------------------------------------------- /src/Random/Float.elm: -------------------------------------------------------------------------------- 1 | module Random.Float exposing (..) 2 | 3 | {-| List of Float Generators 4 | 5 | # Generators 6 | @docs anyFloat, positiveFloat, negativeFloat, floatGreaterThan, floatLessThan, probability, negativeProbability, unitRange 7 | 8 | # Gaussian Generators 9 | @docs normal, standardNormal, gaussian 10 | 11 | -} 12 | 13 | import Random exposing (Generator, map, float, maxInt, minInt, generate) 14 | 15 | 16 | {-| Generator that generates any float 17 | -} 18 | anyFloat : Generator Float 19 | anyFloat = 20 | float (toFloat minInt) (toFloat maxInt) 21 | 22 | 23 | {-| Generator that generates any positive float 24 | -} 25 | positiveFloat : Generator Float 26 | positiveFloat = 27 | float 0 (toFloat maxInt) 28 | 29 | 30 | {-| Generator that generates any negative float 31 | -} 32 | negativeFloat : Generator Float 33 | negativeFloat = 34 | float (toFloat minInt) 0 35 | 36 | 37 | {-| Generator that generates a float greater than a given float 38 | -} 39 | floatGreaterThan : Float -> Generator Float 40 | floatGreaterThan value = 41 | float value (toFloat maxInt) 42 | 43 | 44 | {-| Generator that generates a float less than a given float 45 | -} 46 | floatLessThan : Float -> Generator Float 47 | floatLessThan value = 48 | float (toFloat minInt) value 49 | 50 | 51 | {-| Generator that generates a float between 0 and 1 52 | -} 53 | probability : Generator Float 54 | probability = 55 | float 0 1 56 | 57 | 58 | {-| Generator that generates a float between -1 and 0 59 | -} 60 | negativeProbability : Generator Float 61 | negativeProbability = 62 | float -1 0 63 | 64 | 65 | {-| Generator that generates a float between - 1 and 1 66 | -} 67 | unitRange : Generator Float 68 | unitRange = 69 | float -1 1 70 | 71 | 72 | {-| Create a generator of floats that is normally distributed with 73 | given minimum, maximum, and standard deviation. 74 | -} 75 | normal : Float -> Float -> Float -> Generator Float 76 | normal start end standardDeviation = 77 | let 78 | normalDistribution mean stdDev x = 79 | if stdDev == 0 then 80 | x 81 | else 82 | let 83 | scale = 84 | 1 / (stdDev * sqrt (2 * pi)) 85 | 86 | exponent = 87 | ((x - mean) * (x - mean)) / (2 * stdDev * stdDev) 88 | in 89 | scale * (e ^ -exponent) 90 | in 91 | map (normalDistribution ((end - start) / 2) standardDeviation) (float start end) 92 | 93 | 94 | {-| Generator that follows a standard normal distribution (as opposed to 95 | a uniform distribution) 96 | -} 97 | standardNormal : Generator Float 98 | standardNormal = 99 | normal (toFloat minInt + 1) (toFloat maxInt) 1 100 | 101 | 102 | {-| Alias for `normal`. 103 | -} 104 | gaussian : Float -> Float -> Float -> Generator Float 105 | gaussian = 106 | normal 107 | -------------------------------------------------------------------------------- /src/Random/Array.elm: -------------------------------------------------------------------------------- 1 | module Random.Array exposing (..) 2 | 3 | {-| List of Array Generators 4 | 5 | # Generate an Array 6 | @docs array, emptyArray, rangeLengthArray 7 | 8 | # Random Operations on an Array 9 | @docs sample, choose, shuffle 10 | 11 | -} 12 | 13 | import Array exposing (Array, fromList, empty) 14 | import Random exposing (Generator, map, list, int) 15 | import Random.Extra exposing (flatMap, constant) 16 | 17 | 18 | {-| Generate a random array of given size given a random generator 19 | 20 | randomLength5IntArray = array 5 (int 0 100) 21 | -} 22 | array : Int -> Generator a -> Generator (Array a) 23 | array arrayLength generator = 24 | map fromList (list arrayLength generator) 25 | 26 | 27 | {-| Generator that always generates the empty array 28 | -} 29 | emptyArray : Generator (Array a) 30 | emptyArray = 31 | constant empty 32 | 33 | 34 | {-| Generate a random array of random length given a minimum length and 35 | a maximum length. 36 | -} 37 | rangeLengthArray : Int -> Int -> Generator a -> Generator (Array a) 38 | rangeLengthArray minLength maxLength generator = 39 | flatMap (\len -> array len generator) (int minLength maxLength) 40 | 41 | 42 | {-| Sample with replacement: produce a randomly selected element of the 43 | array, or `Nothing` for an empty array. Takes O(1) time. 44 | -} 45 | sample : Array a -> Generator (Maybe a) 46 | sample arr = 47 | let 48 | gen = 49 | Random.int 0 (Array.length arr - 1) 50 | in 51 | Random.map (\index -> Array.get index arr) gen 52 | 53 | 54 | {-| Sample without replacement: produce a randomly selected element of the 55 | array, and the array with that element omitted (shifting all later elements 56 | down). 57 | -} 58 | choose : Array a -> Generator ( Maybe a, Array a ) 59 | choose arr = 60 | if Array.isEmpty arr then 61 | constant ( Nothing, arr ) 62 | else 63 | let 64 | lastIndex = 65 | Array.length arr - 1 66 | 67 | front i = 68 | Array.slice 0 i arr 69 | 70 | back i = 71 | if 72 | i == lastIndex 73 | -- workaround for #1 74 | then 75 | Array.empty 76 | else 77 | Array.slice (i + 1) (lastIndex + 1) arr 78 | 79 | gen = 80 | Random.int 0 lastIndex 81 | in 82 | Random.map 83 | (\index -> 84 | ( Array.get index arr, Array.append (front index) (back index) ) 85 | ) 86 | gen 87 | 88 | 89 | {-| Shuffle the array using the Fisher-Yates algorithm. Takes O(_n_ log _n_) 90 | time and O(_n_) additional space. 91 | -} 92 | shuffle : Array a -> Generator (Array a) 93 | shuffle arr = 94 | if Array.isEmpty arr then 95 | constant arr 96 | else 97 | let 98 | --helper : (List a, Array a) -> Generator (List a, Array a) 99 | helper ( done, remaining ) = 100 | choose remaining 101 | `Random.andThen` (\( m_val, shorter ) -> 102 | case m_val of 103 | Nothing -> 104 | constant ( done, shorter ) 105 | 106 | Just val -> 107 | helper ( val :: done, shorter ) 108 | ) 109 | in 110 | Random.map (fst >> Array.fromList) (helper ( [], arr )) 111 | -------------------------------------------------------------------------------- /src/Random/String.elm: -------------------------------------------------------------------------------- 1 | module Random.String exposing (..) 2 | 3 | {-| List of String Generators 4 | 5 | # Simple Generators 6 | @docs string, englishWord, capitalizedEnglishWord 7 | 8 | # Random Length String Generators 9 | @docs rangeLengthString, rangeLengthEnglishWord, anyEnglishWord, anyCapitalizedEnglishWord, rangeLengthCapitalizedEnglishWord 10 | 11 | -} 12 | 13 | import String exposing (fromList) 14 | import Random exposing (Generator, map, map2, list, int) 15 | import Random.Char exposing (upperCaseLatin, lowerCaseLatin, unicode) 16 | import Random.Extra exposing (flatMap) 17 | 18 | 19 | {-| Generate a random string of a given length with a given character generator 20 | 21 | fiveLetterEnglishWord = string 5 english 22 | -} 23 | string : Int -> Generator Char -> Generator String 24 | string stringLength charGenerator = 25 | map fromList (list stringLength charGenerator) 26 | 27 | 28 | {-| Generates a random string of random length given the minimum length 29 | and maximum length and a given character generator. 30 | -} 31 | rangeLengthString : Int -> Int -> Generator Char -> Generator String 32 | rangeLengthString minLength maxLength charGenerator = 33 | flatMap (\len -> string len charGenerator) (int minLength maxLength) 34 | 35 | 36 | {-| Generate a random lowercase word with english characters of a given length. 37 | Note: This just generates a random string using the letters in english, so there 38 | are no guarantees that the result be an actual english word. 39 | -} 40 | englishWord : Int -> Generator String 41 | englishWord wordLength = 42 | map fromList (list wordLength lowerCaseLatin) 43 | 44 | 45 | {-| Generate a random lowercase word with english characters of random length 46 | given a minimum length and maximum length. 47 | -} 48 | rangeLengthEnglishWord : Int -> Int -> Generator String 49 | rangeLengthEnglishWord minLength maxLength = 50 | rangeLengthString minLength maxLength lowerCaseLatin 51 | 52 | 53 | {-| Generate a random lowercase word with english characters of random length 54 | between 1 34. 55 | Aside: 34 was picked as a maximum as "supercalifragilisticexpialidocious" 56 | is considered the longest commonly used word and is 34 character long. 57 | Longer words do occur, especially in scientific contexts. In which case, consider 58 | using `rangeLengthEnglishWord` for more granular control. 59 | -} 60 | anyEnglishWord : Generator String 61 | anyEnglishWord = 62 | rangeLengthEnglishWord 1 34 63 | 64 | 65 | {-| Generate a random capitalized word with english characters of a given length. 66 | Note: This just generates a random string using the letters in english, so there 67 | are no guarantees that the result be an actual english word. 68 | -} 69 | capitalizedEnglishWord : Int -> Generator String 70 | capitalizedEnglishWord wordLength = 71 | (map fromList 72 | (map2 (::) 73 | upperCaseLatin 74 | (list (wordLength - 1) lowerCaseLatin) 75 | ) 76 | ) 77 | 78 | 79 | {-| Generate a random capitalized word with english characters of random length 80 | given a minimum length and a maximum length. 81 | -} 82 | rangeLengthCapitalizedEnglishWord : Int -> Int -> Generator String 83 | rangeLengthCapitalizedEnglishWord minLength maxLength = 84 | flatMap capitalizedEnglishWord (int minLength maxLength) 85 | 86 | 87 | {-| Generate a random capitalized word with english characters of random length 88 | between 1 34. 89 | Aside: 34 was picked as a maximum as "supercalifragilisticexpialidocious" 90 | is considered the longest commonly used word and is 34 character long. 91 | Longer words do occur, especially in scientific contexts. In which case, consider 92 | using `rangeLengthEnglishWord` for more granular control. 93 | -} 94 | anyCapitalizedEnglishWord : Generator String 95 | anyCapitalizedEnglishWord = 96 | rangeLengthCapitalizedEnglishWord 1 34 97 | -------------------------------------------------------------------------------- /src/Random/Extra.elm: -------------------------------------------------------------------------------- 1 | module Random.Extra exposing (..) 2 | 3 | {-| Module providing extra functionality to the core Random module. 4 | 5 | # Constant Generators 6 | @docs constant 7 | 8 | # Generator Transformers 9 | @docs flattenList 10 | 11 | # Select 12 | @docs select, selectWithDefault, frequency, merge 13 | 14 | # Maps 15 | For `map` and `mapN` up through N=5, use the core library. 16 | @docs map6, andMap, mapConstraint 17 | 18 | # Flat Maps 19 | @docs flatMap, flatMap2, flatMap3, flatMap4, flatMap5, flatMap6 20 | 21 | # Zips 22 | @docs zip, zip3, zip4, zip5, zip6 23 | 24 | # Reducers 25 | @docs reduce, fold 26 | 27 | # Filtering Generators 28 | @docs keepIf, dropIf 29 | 30 | # Functions that generate random values from Generators 31 | @docs generateN, quickGenerate, cappedGenerateUntil, generateIterativelyUntil, generateIterativelySuchThat, generateUntil, generateSuchThat 32 | 33 | -} 34 | 35 | import Random exposing (Generator, Seed, step, list, int, float, initialSeed) 36 | import Utils exposing (get) 37 | import List 38 | import Maybe 39 | 40 | 41 | {-| Create a generator that chooses a generator from a tuple of generators 42 | based on the provided likelihood. The likelihood of a given generator being 43 | chosen is its likelihood divided by the sum of all likelihood. A default 44 | generator must be provided in the case that the list is empty or that the 45 | sum of the likelihoods is 0. Note that the absolute values of the likelihoods 46 | is always taken. 47 | -} 48 | frequency : List ( Float, Generator a ) -> Generator a -> Generator a 49 | frequency pairs defaultGenerator = 50 | let 51 | total = 52 | List.sum <| List.map (abs << fst) pairs 53 | 54 | pick choices n = 55 | case choices of 56 | ( k, g ) :: rest -> 57 | if n <= k then 58 | g 59 | else 60 | pick rest (n - k) 61 | 62 | _ -> 63 | defaultGenerator 64 | in 65 | if total == 0 then 66 | defaultGenerator 67 | else 68 | float 0 total `Random.andThen` pick pairs 69 | 70 | 71 | {-| Convert a generator into a generator that only generates values 72 | that satisfy a given predicate. 73 | Note that if the predicate is unsatisfiable, the generator will not terminate. 74 | -} 75 | keepIf : (a -> Bool) -> Generator a -> Generator a 76 | keepIf predicate generator = 77 | generator 78 | `Random.andThen` (\a -> 79 | if predicate a then 80 | constant a 81 | else 82 | keepIf predicate generator 83 | ) 84 | 85 | 86 | {-| Convert a generator into a generator that only generates values 87 | that do not satisfy a given predicate. 88 | -} 89 | dropIf : (a -> Bool) -> Generator a -> Generator a 90 | dropIf predicate = 91 | keepIf (\a -> not (predicate a)) 92 | 93 | 94 | {-| Turn a list of generators into a generator of lists. 95 | -} 96 | flattenList : List (Generator a) -> Generator (List a) 97 | flattenList generators = 98 | case generators of 99 | [] -> 100 | constant [] 101 | 102 | g :: gs -> 103 | Random.map2 (::) g (flattenList gs) 104 | 105 | 106 | {-| Generator that randomly selects an element from a list. 107 | -} 108 | select : List a -> Generator (Maybe a) 109 | select list = 110 | Random.map (\index -> get index list) 111 | (int 0 (List.length list - 1)) 112 | 113 | 114 | {-| Generator that randomly selects an element from a list with a default value 115 | (in case you pass in an empty list). 116 | -} 117 | selectWithDefault : a -> List a -> Generator a 118 | selectWithDefault defaultValue list = 119 | Random.map (Maybe.withDefault defaultValue) (select list) 120 | 121 | 122 | {-| Create a generator that always returns the same value. 123 | -} 124 | constant : a -> Generator a 125 | constant value = 126 | Random.map (\_ -> value) Random.bool 127 | 128 | 129 | {-| Apply a generator of functions to a generator of values. 130 | Useful for chaining generators. 131 | -} 132 | andMap : Generator (a -> b) -> Generator a -> Generator b 133 | andMap funcGenerator generator = 134 | Random.map2 (<|) funcGenerator generator 135 | 136 | 137 | {-| Reduce a generator using a reducer and an initial value. 138 | Note that the initial value is always passed to the function; 139 | not the previously generator value. 140 | -} 141 | reduce : (a -> b -> b) -> b -> Generator a -> Generator b 142 | reduce reducer initial generator = 143 | Random.map (\a -> reducer a initial) generator 144 | 145 | 146 | {-| Alias for reduce. 147 | -} 148 | fold : (a -> b -> b) -> b -> Generator a -> Generator b 149 | fold = 150 | reduce 151 | 152 | 153 | {-| -} 154 | zip : Generator a -> Generator b -> Generator ( a, b ) 155 | zip = 156 | Random.map2 (,) 157 | 158 | 159 | {-| -} 160 | zip3 : Generator a -> Generator b -> Generator c -> Generator ( a, b, c ) 161 | zip3 = 162 | Random.map3 (,,) 163 | 164 | 165 | {-| -} 166 | zip4 : Generator a -> Generator b -> Generator c -> Generator d -> Generator ( a, b, c, d ) 167 | zip4 = 168 | Random.map4 (,,,) 169 | 170 | 171 | {-| -} 172 | zip5 : Generator a -> Generator b -> Generator c -> Generator d -> Generator e -> Generator ( a, b, c, d, e ) 173 | zip5 = 174 | Random.map5 (,,,,) 175 | 176 | 177 | {-| -} 178 | zip6 : Generator a -> Generator b -> Generator c -> Generator d -> Generator e -> Generator f -> Generator ( a, b, c, d, e, f ) 179 | zip6 = 180 | map6 (,,,,,) 181 | 182 | 183 | {-| -} 184 | flatMap : (a -> Generator b) -> Generator a -> Generator b 185 | flatMap = 186 | flip Random.andThen 187 | 188 | 189 | {-| -} 190 | flatMap2 : (a -> b -> Generator c) -> Generator a -> Generator b -> Generator c 191 | flatMap2 constructor generatorA generatorB = 192 | generatorA 193 | `Random.andThen` (\a -> 194 | generatorB 195 | `Random.andThen` (\b -> 196 | constructor a b 197 | ) 198 | ) 199 | 200 | 201 | {-| -} 202 | flatMap3 : (a -> b -> c -> Generator d) -> Generator a -> Generator b -> Generator c -> Generator d 203 | flatMap3 constructor generatorA generatorB generatorC = 204 | generatorA 205 | `Random.andThen` (\a -> 206 | generatorB 207 | `Random.andThen` (\b -> 208 | generatorC 209 | `Random.andThen` (\c -> 210 | constructor a b c 211 | ) 212 | ) 213 | ) 214 | 215 | 216 | {-| -} 217 | flatMap4 : (a -> b -> c -> d -> Generator e) -> Generator a -> Generator b -> Generator c -> Generator d -> Generator e 218 | flatMap4 constructor generatorA generatorB generatorC generatorD = 219 | generatorA 220 | `Random.andThen` (\a -> 221 | generatorB 222 | `Random.andThen` (\b -> 223 | generatorC 224 | `Random.andThen` (\c -> 225 | generatorD 226 | `Random.andThen` (\d -> 227 | constructor a b c d 228 | ) 229 | ) 230 | ) 231 | ) 232 | 233 | 234 | {-| -} 235 | flatMap5 : (a -> b -> c -> d -> e -> Generator f) -> Generator a -> Generator b -> Generator c -> Generator d -> Generator e -> Generator f 236 | flatMap5 constructor generatorA generatorB generatorC generatorD generatorE = 237 | generatorA 238 | `Random.andThen` (\a -> 239 | generatorB 240 | `Random.andThen` (\b -> 241 | generatorC 242 | `Random.andThen` (\c -> 243 | generatorD 244 | `Random.andThen` (\d -> 245 | generatorE 246 | `Random.andThen` (\e -> 247 | constructor a b c d e 248 | ) 249 | ) 250 | ) 251 | ) 252 | ) 253 | 254 | 255 | {-| -} 256 | flatMap6 : (a -> b -> c -> d -> e -> f -> Generator g) -> Generator a -> Generator b -> Generator c -> Generator d -> Generator e -> Generator f -> Generator g 257 | flatMap6 constructor generatorA generatorB generatorC generatorD generatorE generatorF = 258 | generatorA 259 | `Random.andThen` (\a -> 260 | generatorB 261 | `Random.andThen` (\b -> 262 | generatorC 263 | `Random.andThen` (\c -> 264 | generatorD 265 | `Random.andThen` (\d -> 266 | generatorE 267 | `Random.andThen` (\e -> 268 | generatorF 269 | `Random.andThen` (\f -> 270 | constructor a b c d e f 271 | ) 272 | ) 273 | ) 274 | ) 275 | ) 276 | ) 277 | 278 | 279 | {-| -} 280 | map6 : (a -> b -> c -> d -> e -> f -> g) -> Generator a -> Generator b -> Generator c -> Generator d -> Generator e -> Generator f -> Generator g 281 | map6 f generatorA generatorB generatorC generatorD generatorE generatorF = 282 | Random.map5 f generatorA generatorB generatorC generatorD generatorE `andMap` generatorF 283 | 284 | 285 | {-| Choose between two generators with a 50-50 chance. 286 | Useful for merging two generators that cover different areas of the same type. 287 | -} 288 | merge : Generator a -> Generator a -> Generator a 289 | merge generator1 generator2 = 290 | frequency 291 | [ ( 1, generator1 ) 292 | , ( 1, generator2 ) 293 | ] 294 | generator1 295 | 296 | 297 | {-| Generate n values from a generator. 298 | -} 299 | generateN : Int -> Generator a -> Seed -> List a 300 | generateN n generator seed = 301 | if n <= 0 then 302 | [] 303 | else 304 | let 305 | ( value, nextSeed ) = 306 | step generator seed 307 | in 308 | value :: generateN (n - 1) generator nextSeed 309 | 310 | 311 | {-| Generate a value from a generator that satisfies a given predicate 312 | -} 313 | generateSuchThat : (a -> Bool) -> Generator a -> Seed -> ( a, Seed ) 314 | generateSuchThat predicate generator seed = 315 | step (keepIf predicate generator) seed 316 | 317 | 318 | {-| Generate a list of values from a generator until the given predicate 319 | is satisfied 320 | -} 321 | generateUntil : (a -> Bool) -> Generator a -> Seed -> List a 322 | generateUntil predicate generator seed = 323 | let 324 | ( value, nextSeed ) = 325 | step generator seed 326 | in 327 | if predicate value then 328 | value :: generateUntil predicate generator nextSeed 329 | else 330 | [] 331 | 332 | 333 | {-| Generate iteratively a list of values from a generator parametrized by 334 | the value of the iterator until either the given maxlength is reached or 335 | the predicate ceases to be satisfied. 336 | 337 | generateIterativelySuchThat maxLength predicate constructor seed 338 | -} 339 | generateIterativelySuchThat : Int -> (a -> Bool) -> (Int -> Generator a) -> Seed -> List a 340 | generateIterativelySuchThat maxLength predicate = 341 | generateIterativelyUntil maxLength (\a -> not (predicate a)) 342 | 343 | 344 | {-| Generate iteratively a list of values from a generator parametrized by 345 | the value of the iterator until either the given maxlength is reached or 346 | the predicate is satisfied. 347 | 348 | generateIterativelyUntil maxLength predicate constructor seed 349 | -} 350 | generateIterativelyUntil : Int -> (a -> Bool) -> (Int -> Generator a) -> Seed -> List a 351 | generateIterativelyUntil maxLength predicate constructor seed = 352 | let 353 | iterate index = 354 | if index >= maxLength then 355 | [] 356 | else 357 | (generateUntil predicate (constructor index) seed) 358 | ++ (iterate (index + 1)) 359 | in 360 | iterate 0 361 | 362 | 363 | {-| Generate iteratively a list of values from a generator until either 364 | the given maxlength is reached or the predicate is satisfied. 365 | 366 | cappedGenerateUntil maxLength predicate generator seed 367 | -} 368 | cappedGenerateUntil : Int -> (a -> Bool) -> Generator a -> Seed -> List a 369 | cappedGenerateUntil maxGenerations predicate generator seed = 370 | if maxGenerations <= 0 then 371 | [] 372 | else 373 | let 374 | ( value, nextSeed ) = 375 | step generator seed 376 | in 377 | if predicate value then 378 | value :: cappedGenerateUntil (maxGenerations - 1) predicate generator nextSeed 379 | else 380 | [] 381 | 382 | 383 | {-| Quickly generate a value from a generator disregarding seeds. 384 | -} 385 | quickGenerate : Generator a -> a 386 | quickGenerate generator = 387 | (fst (step generator (initialSeed 1))) 388 | 389 | 390 | {-| Apply a constraint onto a generator and returns both the input to 391 | the constraint and the result of applying the constaint. 392 | -} 393 | mapConstraint : (a -> b) -> Generator a -> Generator ( a, b ) 394 | mapConstraint constraint generator = 395 | Random.map (\a -> ( a, constraint a )) generator 396 | -------------------------------------------------------------------------------- /src/Random/Char.elm: -------------------------------------------------------------------------------- 1 | module Random.Char exposing (..) 2 | 3 | {-| List of Char Generators 4 | 5 | # Basic Generators 6 | @docs char, lowerCaseLatin, upperCaseLatin, latin, english, ascii, unicode 7 | 8 | # Unicode Generators (UTF-8) 9 | @docs basicLatin, latin1Supplement, latinExtendedA, latinExtendedB, ipaExtensions, spacingModifier, combiningDiacriticalMarks, greekAndCoptic, cyrillic, cyrillicSupplement, armenian, hebrew, arabic, syriac, arabicSupplement, thaana, nko, samaritan, mandaic, arabicExtendedA, devanagari, bengali, gurmukhi, gujarati, oriya, tamil, telugu, kannada, malayalam, sinhala, thai, lao, tibetan, myanmar, georgian, hangulJamo, ethiopic, ethiopicSupplement, cherokee, unifiedCanadianAboriginalSyllabic, ogham, runic, tagalog, hanunoo, buhid, tagbanwa, khmer, mongolian, unifiedCanadianAboriginalSyllabicExtended, limbu, taiLe, newTaiLue, khmerSymbol, buginese, taiTham, balinese, sundanese, batak, lepcha, olChiki, sundaneseSupplement, vedicExtensions, phoneticExtensions, phoneticExtensionsSupplement, combiningDiacriticalMarksSupplement, latinExtendedAdditional, greekExtended, generalPunctuation, superscriptOrSubscript, currencySymbol, combiningDiacriticalMarksForSymbols, letterlikeSymbol, numberForm, arrow, mathematicalOperator, miscellaneousTechnical, controlPicture, opticalCharacterRecognition, enclosedAlphanumeric, boxDrawing, blockElement, geometricShape, miscellaneousSymbol, dingbat, miscellaneousMathematicalSymbolA, supplementalArrowA, braillePattern, supplementalArrowB, miscellaneousMathematicalSymbolB, supplementalMathematicalOperator, miscellaneousSymbolOrArrow, glagolitic, latinExtendedC, coptic, georgianSupplement, tifinagh, ethiopicExtended, cyrillicExtendedA, supplementalPunctuation, cjkRadicalSupplement, kangxiRadical, ideographicDescription, cjkSymbolOrPunctuation, hiragana, katakana, bopomofo, hangulCompatibilityJamo, kanbun, bopomofoExtended, cjkStroke, katakanaPhoneticExtension, enclosedCJKLetterOrMonth, cjkCompatibility, cjkUnifiedIdeographExtensionA, yijingHexagramSymbol, cjkUnifiedIdeograph, yiSyllable, yiRadical, lisu, vai, cyrillicExtendedB, bamum, modifierToneLetter, latinExtendedD, sylotiNagri, commonIndicNumberForm, phagsPa, saurashtra, devanagariExtended, kayahLi, rejang, hangulJamoExtendedA, javanese, cham, myanmarExtendedA, taiViet, meeteiMayekExtension, ethiopicExtendedA, meeteiMayek, hangulSyllable, hangulJamoExtendedB, highSurrogate, highPrivateUseSurrogate, lowSurrogate, privateUseArea, cjkCompatibilityIdeograph, alphabeticPresentationForm, arabicPresentationFormA, variationSelector, verticalForm, combiningHalfMark, cjkCompatibilityForm, smallFormVariant, arabicPresentationFormB, halfwidthOrFullwidthForm, special, linearBSyllable, linearBIdeogram, aegeanNumber, ancientGreekNumber, ancientSymbol, phaistosDisc, lycian, carian, oldItalic, gothic, ugaritic, oldPersian, deseret, shavian, osmanya, cypriotSyllable, imperialAramaic, phoenician, lydian, meroiticHieroglyph, meroiticCursive, kharoshthi, oldSouthArabian, avestan, inscriptionalParthian, inscriptionalPahlavi, oldTurkic, rumiNumericalSymbol, brahmi, kaithi, soraSompeng, chakma, sharada, takri, cuneiform, cuneiformNumberOrPunctuation, egyptianHieroglyph, bamumSupplement, miao, kanaSupplement, byzantineMusicalSymbol, musicalSymbol, ancientGreekMusicalNotationSymbol, taiXuanJingSymbol, countingRodNumeral, mathematicalAlphanumericSymbol, arabicMathematicalAlphabeticSymbol, mahjongTile, dominoTile, playingCard, enclosedAlphanumericSupplement, enclosedIdeographicSupplement, miscellaneousSymbolOrPictograph, emoticon, transportOrMapSymbol, alchemicalSymbol, cjkUnifiedIdeographExtensionB, cjkUnifiedIdeographExtensionC, cjkUnifiedIdeographExtensionD, cjkCompatibilityIdeographSupplement, tag, variationSelectorSupplement, supplementaryPrivateUseAreaA, supplementaryPrivateUseAreaB 10 | 11 | -} 12 | 13 | import Char exposing (fromCode) 14 | import Random exposing (Generator, map, int) 15 | import Random.Extra exposing (merge) 16 | 17 | 18 | {-| Generate a random character within a certain keyCode range 19 | 20 | lowerCaseLetter = char 65 90 21 | -} 22 | char : Int -> Int -> Generator Char 23 | char start end = 24 | map fromCode (int start end) 25 | 26 | 27 | {-| Generate a random upper-case Latin Letter 28 | -} 29 | upperCaseLatin : Generator Char 30 | upperCaseLatin = 31 | char 65 90 32 | 33 | 34 | {-| Generate a random lower-case Latin Letter 35 | -} 36 | lowerCaseLatin : Generator Char 37 | lowerCaseLatin = 38 | char 97 122 39 | 40 | 41 | {-| Generate a random Latin Letter 42 | -} 43 | latin : Generator Char 44 | latin = 45 | merge lowerCaseLatin upperCaseLatin 46 | 47 | 48 | {-| Generate a random English Letter (alias for `latin`) 49 | -} 50 | english : Generator Char 51 | english = 52 | latin 53 | 54 | 55 | {-| Generate a random ASCII Character 56 | -} 57 | ascii : Generator Char 58 | ascii = 59 | char 0 127 60 | 61 | 62 | {-| Generate a random Character in the valid unicode range. 63 | Note: This can produce garbage values as unicode doesn't use all valid values. 64 | To test for specific languages and character sets, use the appropriate one 65 | from the list. 66 | -} 67 | unicode : Generator Char 68 | unicode = 69 | char 0 1114111 70 | 71 | 72 | {-| UTF-8 73 | -} 74 | basicLatin : Generator Char 75 | basicLatin = 76 | char 0 127 77 | 78 | 79 | {-| -} 80 | latin1Supplement : Generator Char 81 | latin1Supplement = 82 | char 128 255 83 | 84 | 85 | {-| -} 86 | latinExtendedA : Generator Char 87 | latinExtendedA = 88 | char 256 383 89 | 90 | 91 | {-| -} 92 | latinExtendedB : Generator Char 93 | latinExtendedB = 94 | char 384 591 95 | 96 | 97 | {-| -} 98 | ipaExtensions : Generator Char 99 | ipaExtensions = 100 | char 592 687 101 | 102 | 103 | {-| -} 104 | spacingModifier : Generator Char 105 | spacingModifier = 106 | char 688 767 107 | 108 | 109 | {-| -} 110 | combiningDiacriticalMarks : Generator Char 111 | combiningDiacriticalMarks = 112 | char 768 879 113 | 114 | 115 | {-| -} 116 | greekAndCoptic : Generator Char 117 | greekAndCoptic = 118 | char 880 1023 119 | 120 | 121 | {-| -} 122 | cyrillic : Generator Char 123 | cyrillic = 124 | char 1024 1279 125 | 126 | 127 | {-| -} 128 | cyrillicSupplement : Generator Char 129 | cyrillicSupplement = 130 | char 1280 1327 131 | 132 | 133 | {-| -} 134 | armenian : Generator Char 135 | armenian = 136 | char 1328 1423 137 | 138 | 139 | {-| -} 140 | hebrew : Generator Char 141 | hebrew = 142 | char 1424 1535 143 | 144 | 145 | {-| -} 146 | arabic : Generator Char 147 | arabic = 148 | char 1536 1791 149 | 150 | 151 | {-| -} 152 | syriac : Generator Char 153 | syriac = 154 | char 1792 1871 155 | 156 | 157 | {-| -} 158 | arabicSupplement : Generator Char 159 | arabicSupplement = 160 | char 1872 1919 161 | 162 | 163 | {-| -} 164 | thaana : Generator Char 165 | thaana = 166 | char 1920 1983 167 | 168 | 169 | {-| -} 170 | nko : Generator Char 171 | nko = 172 | char 1984 2047 173 | 174 | 175 | {-| -} 176 | samaritan : Generator Char 177 | samaritan = 178 | char 2048 2111 179 | 180 | 181 | {-| -} 182 | mandaic : Generator Char 183 | mandaic = 184 | char 2112 2143 185 | 186 | 187 | {-| -} 188 | arabicExtendedA : Generator Char 189 | arabicExtendedA = 190 | char 2208 2303 191 | 192 | 193 | {-| -} 194 | devanagari : Generator Char 195 | devanagari = 196 | char 2304 2431 197 | 198 | 199 | {-| -} 200 | bengali : Generator Char 201 | bengali = 202 | char 2432 2559 203 | 204 | 205 | {-| -} 206 | gurmukhi : Generator Char 207 | gurmukhi = 208 | char 2560 2687 209 | 210 | 211 | {-| -} 212 | gujarati : Generator Char 213 | gujarati = 214 | char 2688 2815 215 | 216 | 217 | {-| -} 218 | oriya : Generator Char 219 | oriya = 220 | char 2816 2943 221 | 222 | 223 | {-| -} 224 | tamil : Generator Char 225 | tamil = 226 | char 2944 3071 227 | 228 | 229 | {-| -} 230 | telugu : Generator Char 231 | telugu = 232 | char 3072 3199 233 | 234 | 235 | {-| -} 236 | kannada : Generator Char 237 | kannada = 238 | char 3200 3327 239 | 240 | 241 | {-| -} 242 | malayalam : Generator Char 243 | malayalam = 244 | char 3328 3455 245 | 246 | 247 | {-| -} 248 | sinhala : Generator Char 249 | sinhala = 250 | char 3456 3583 251 | 252 | 253 | {-| -} 254 | thai : Generator Char 255 | thai = 256 | char 3584 3711 257 | 258 | 259 | {-| -} 260 | lao : Generator Char 261 | lao = 262 | char 3712 3839 263 | 264 | 265 | {-| -} 266 | tibetan : Generator Char 267 | tibetan = 268 | char 3840 4095 269 | 270 | 271 | {-| -} 272 | myanmar : Generator Char 273 | myanmar = 274 | char 4096 4255 275 | 276 | 277 | {-| -} 278 | georgian : Generator Char 279 | georgian = 280 | char 4256 4351 281 | 282 | 283 | {-| -} 284 | hangulJamo : Generator Char 285 | hangulJamo = 286 | char 4352 4607 287 | 288 | 289 | {-| -} 290 | ethiopic : Generator Char 291 | ethiopic = 292 | char 4608 4991 293 | 294 | 295 | {-| -} 296 | ethiopicSupplement : Generator Char 297 | ethiopicSupplement = 298 | char 4992 5023 299 | 300 | 301 | {-| -} 302 | cherokee : Generator Char 303 | cherokee = 304 | char 5024 5119 305 | 306 | 307 | {-| -} 308 | unifiedCanadianAboriginalSyllabic : Generator Char 309 | unifiedCanadianAboriginalSyllabic = 310 | char 5120 5759 311 | 312 | 313 | {-| -} 314 | ogham : Generator Char 315 | ogham = 316 | char 5760 5791 317 | 318 | 319 | {-| -} 320 | runic : Generator Char 321 | runic = 322 | char 5792 5887 323 | 324 | 325 | {-| -} 326 | tagalog : Generator Char 327 | tagalog = 328 | char 5888 5919 329 | 330 | 331 | {-| -} 332 | hanunoo : Generator Char 333 | hanunoo = 334 | char 5920 5951 335 | 336 | 337 | {-| -} 338 | buhid : Generator Char 339 | buhid = 340 | char 5952 5983 341 | 342 | 343 | {-| -} 344 | tagbanwa : Generator Char 345 | tagbanwa = 346 | char 5984 6015 347 | 348 | 349 | {-| -} 350 | khmer : Generator Char 351 | khmer = 352 | char 6016 6143 353 | 354 | 355 | {-| -} 356 | mongolian : Generator Char 357 | mongolian = 358 | char 6144 6319 359 | 360 | 361 | {-| -} 362 | unifiedCanadianAboriginalSyllabicExtended : Generator Char 363 | unifiedCanadianAboriginalSyllabicExtended = 364 | char 6320 6399 365 | 366 | 367 | {-| -} 368 | limbu : Generator Char 369 | limbu = 370 | char 6400 6479 371 | 372 | 373 | {-| -} 374 | taiLe : Generator Char 375 | taiLe = 376 | char 6480 6527 377 | 378 | 379 | {-| -} 380 | newTaiLue : Generator Char 381 | newTaiLue = 382 | char 6528 6623 383 | 384 | 385 | {-| -} 386 | khmerSymbol : Generator Char 387 | khmerSymbol = 388 | char 6624 6655 389 | 390 | 391 | {-| -} 392 | buginese : Generator Char 393 | buginese = 394 | char 6656 6687 395 | 396 | 397 | {-| -} 398 | taiTham : Generator Char 399 | taiTham = 400 | char 6688 6831 401 | 402 | 403 | {-| -} 404 | balinese : Generator Char 405 | balinese = 406 | char 6912 7039 407 | 408 | 409 | {-| -} 410 | sundanese : Generator Char 411 | sundanese = 412 | char 7040 7103 413 | 414 | 415 | {-| -} 416 | batak : Generator Char 417 | batak = 418 | char 7104 7167 419 | 420 | 421 | {-| -} 422 | lepcha : Generator Char 423 | lepcha = 424 | char 7168 7247 425 | 426 | 427 | {-| -} 428 | olChiki : Generator Char 429 | olChiki = 430 | char 7248 7295 431 | 432 | 433 | {-| -} 434 | sundaneseSupplement : Generator Char 435 | sundaneseSupplement = 436 | char 7360 7375 437 | 438 | 439 | {-| -} 440 | vedicExtensions : Generator Char 441 | vedicExtensions = 442 | char 7376 7423 443 | 444 | 445 | {-| -} 446 | phoneticExtensions : Generator Char 447 | phoneticExtensions = 448 | char 7424 7551 449 | 450 | 451 | {-| -} 452 | phoneticExtensionsSupplement : Generator Char 453 | phoneticExtensionsSupplement = 454 | char 7552 7615 455 | 456 | 457 | {-| -} 458 | combiningDiacriticalMarksSupplement : Generator Char 459 | combiningDiacriticalMarksSupplement = 460 | char 7616 7679 461 | 462 | 463 | {-| -} 464 | latinExtendedAdditional : Generator Char 465 | latinExtendedAdditional = 466 | char 7680 7935 467 | 468 | 469 | {-| -} 470 | greekExtended : Generator Char 471 | greekExtended = 472 | char 7936 8191 473 | 474 | 475 | {-| -} 476 | generalPunctuation : Generator Char 477 | generalPunctuation = 478 | char 8192 8303 479 | 480 | 481 | {-| -} 482 | superscriptOrSubscript : Generator Char 483 | superscriptOrSubscript = 484 | char 8304 8351 485 | 486 | 487 | {-| -} 488 | currencySymbol : Generator Char 489 | currencySymbol = 490 | char 8352 8399 491 | 492 | 493 | {-| -} 494 | combiningDiacriticalMarksForSymbols : Generator Char 495 | combiningDiacriticalMarksForSymbols = 496 | char 8400 8447 497 | 498 | 499 | {-| -} 500 | letterlikeSymbol : Generator Char 501 | letterlikeSymbol = 502 | char 8448 8527 503 | 504 | 505 | {-| -} 506 | numberForm : Generator Char 507 | numberForm = 508 | char 8528 8591 509 | 510 | 511 | {-| -} 512 | arrow : Generator Char 513 | arrow = 514 | char 8592 8703 515 | 516 | 517 | {-| -} 518 | mathematicalOperator : Generator Char 519 | mathematicalOperator = 520 | char 8704 8959 521 | 522 | 523 | {-| -} 524 | miscellaneousTechnical : Generator Char 525 | miscellaneousTechnical = 526 | char 8960 9215 527 | 528 | 529 | {-| -} 530 | controlPicture : Generator Char 531 | controlPicture = 532 | char 9216 9279 533 | 534 | 535 | {-| -} 536 | opticalCharacterRecognition : Generator Char 537 | opticalCharacterRecognition = 538 | char 9280 9311 539 | 540 | 541 | {-| -} 542 | enclosedAlphanumeric : Generator Char 543 | enclosedAlphanumeric = 544 | char 9312 9471 545 | 546 | 547 | {-| -} 548 | boxDrawing : Generator Char 549 | boxDrawing = 550 | char 9472 9599 551 | 552 | 553 | {-| -} 554 | blockElement : Generator Char 555 | blockElement = 556 | char 9600 9631 557 | 558 | 559 | {-| -} 560 | geometricShape : Generator Char 561 | geometricShape = 562 | char 9632 9727 563 | 564 | 565 | {-| -} 566 | miscellaneousSymbol : Generator Char 567 | miscellaneousSymbol = 568 | char 9728 9983 569 | 570 | 571 | {-| -} 572 | dingbat : Generator Char 573 | dingbat = 574 | char 9984 10175 575 | 576 | 577 | {-| -} 578 | miscellaneousMathematicalSymbolA : Generator Char 579 | miscellaneousMathematicalSymbolA = 580 | char 10176 10223 581 | 582 | 583 | {-| -} 584 | supplementalArrowA : Generator Char 585 | supplementalArrowA = 586 | char 10224 10239 587 | 588 | 589 | {-| -} 590 | braillePattern : Generator Char 591 | braillePattern = 592 | char 10240 10495 593 | 594 | 595 | {-| -} 596 | supplementalArrowB : Generator Char 597 | supplementalArrowB = 598 | char 10496 10623 599 | 600 | 601 | {-| -} 602 | miscellaneousMathematicalSymbolB : Generator Char 603 | miscellaneousMathematicalSymbolB = 604 | char 10624 10751 605 | 606 | 607 | {-| -} 608 | supplementalMathematicalOperator : Generator Char 609 | supplementalMathematicalOperator = 610 | char 10752 11007 611 | 612 | 613 | {-| -} 614 | miscellaneousSymbolOrArrow : Generator Char 615 | miscellaneousSymbolOrArrow = 616 | char 11008 11263 617 | 618 | 619 | {-| -} 620 | glagolitic : Generator Char 621 | glagolitic = 622 | char 11264 11359 623 | 624 | 625 | {-| -} 626 | latinExtendedC : Generator Char 627 | latinExtendedC = 628 | char 11360 11391 629 | 630 | 631 | {-| -} 632 | coptic : Generator Char 633 | coptic = 634 | char 11392 11519 635 | 636 | 637 | {-| -} 638 | georgianSupplement : Generator Char 639 | georgianSupplement = 640 | char 11520 11567 641 | 642 | 643 | {-| -} 644 | tifinagh : Generator Char 645 | tifinagh = 646 | char 11568 11647 647 | 648 | 649 | {-| -} 650 | ethiopicExtended : Generator Char 651 | ethiopicExtended = 652 | char 11648 11743 653 | 654 | 655 | {-| -} 656 | cyrillicExtendedA : Generator Char 657 | cyrillicExtendedA = 658 | char 11744 11775 659 | 660 | 661 | {-| -} 662 | supplementalPunctuation : Generator Char 663 | supplementalPunctuation = 664 | char 11776 11903 665 | 666 | 667 | {-| -} 668 | cjkRadicalSupplement : Generator Char 669 | cjkRadicalSupplement = 670 | char 11904 12031 671 | 672 | 673 | {-| -} 674 | kangxiRadical : Generator Char 675 | kangxiRadical = 676 | char 12032 12255 677 | 678 | 679 | {-| -} 680 | ideographicDescription : Generator Char 681 | ideographicDescription = 682 | char 12272 12287 683 | 684 | 685 | {-| -} 686 | cjkSymbolOrPunctuation : Generator Char 687 | cjkSymbolOrPunctuation = 688 | char 12288 12351 689 | 690 | 691 | {-| -} 692 | hiragana : Generator Char 693 | hiragana = 694 | char 12352 12447 695 | 696 | 697 | {-| -} 698 | katakana : Generator Char 699 | katakana = 700 | char 12448 12543 701 | 702 | 703 | {-| -} 704 | bopomofo : Generator Char 705 | bopomofo = 706 | char 12544 12591 707 | 708 | 709 | {-| -} 710 | hangulCompatibilityJamo : Generator Char 711 | hangulCompatibilityJamo = 712 | char 12592 12687 713 | 714 | 715 | {-| -} 716 | kanbun : Generator Char 717 | kanbun = 718 | char 12688 12703 719 | 720 | 721 | {-| -} 722 | bopomofoExtended : Generator Char 723 | bopomofoExtended = 724 | char 12704 12735 725 | 726 | 727 | {-| -} 728 | cjkStroke : Generator Char 729 | cjkStroke = 730 | char 12736 12783 731 | 732 | 733 | {-| -} 734 | katakanaPhoneticExtension : Generator Char 735 | katakanaPhoneticExtension = 736 | char 12784 12799 737 | 738 | 739 | {-| -} 740 | enclosedCJKLetterOrMonth : Generator Char 741 | enclosedCJKLetterOrMonth = 742 | char 12800 13055 743 | 744 | 745 | {-| -} 746 | cjkCompatibility : Generator Char 747 | cjkCompatibility = 748 | char 13056 13311 749 | 750 | 751 | {-| -} 752 | cjkUnifiedIdeographExtensionA : Generator Char 753 | cjkUnifiedIdeographExtensionA = 754 | char 13312 19903 755 | 756 | 757 | {-| -} 758 | yijingHexagramSymbol : Generator Char 759 | yijingHexagramSymbol = 760 | char 19904 19967 761 | 762 | 763 | {-| -} 764 | cjkUnifiedIdeograph : Generator Char 765 | cjkUnifiedIdeograph = 766 | char 19968 40959 767 | 768 | 769 | {-| -} 770 | yiSyllable : Generator Char 771 | yiSyllable = 772 | char 40960 42127 773 | 774 | 775 | {-| -} 776 | yiRadical : Generator Char 777 | yiRadical = 778 | char 42128 42191 779 | 780 | 781 | {-| -} 782 | lisu : Generator Char 783 | lisu = 784 | char 42192 42239 785 | 786 | 787 | {-| -} 788 | vai : Generator Char 789 | vai = 790 | char 42240 42559 791 | 792 | 793 | {-| -} 794 | cyrillicExtendedB : Generator Char 795 | cyrillicExtendedB = 796 | char 42560 42655 797 | 798 | 799 | {-| -} 800 | bamum : Generator Char 801 | bamum = 802 | char 42656 42751 803 | 804 | 805 | {-| -} 806 | modifierToneLetter : Generator Char 807 | modifierToneLetter = 808 | char 42752 42783 809 | 810 | 811 | {-| -} 812 | latinExtendedD : Generator Char 813 | latinExtendedD = 814 | char 42784 43007 815 | 816 | 817 | {-| -} 818 | sylotiNagri : Generator Char 819 | sylotiNagri = 820 | char 43008 43055 821 | 822 | 823 | {-| -} 824 | commonIndicNumberForm : Generator Char 825 | commonIndicNumberForm = 826 | char 43056 43071 827 | 828 | 829 | {-| -} 830 | phagsPa : Generator Char 831 | phagsPa = 832 | char 43072 43135 833 | 834 | 835 | {-| -} 836 | saurashtra : Generator Char 837 | saurashtra = 838 | char 43136 43231 839 | 840 | 841 | {-| -} 842 | devanagariExtended : Generator Char 843 | devanagariExtended = 844 | char 43232 43263 845 | 846 | 847 | {-| -} 848 | kayahLi : Generator Char 849 | kayahLi = 850 | char 43264 43311 851 | 852 | 853 | {-| -} 854 | rejang : Generator Char 855 | rejang = 856 | char 43312 43359 857 | 858 | 859 | {-| -} 860 | hangulJamoExtendedA : Generator Char 861 | hangulJamoExtendedA = 862 | char 43360 43391 863 | 864 | 865 | {-| -} 866 | javanese : Generator Char 867 | javanese = 868 | char 43392 43487 869 | 870 | 871 | {-| -} 872 | cham : Generator Char 873 | cham = 874 | char 43520 43615 875 | 876 | 877 | {-| -} 878 | myanmarExtendedA : Generator Char 879 | myanmarExtendedA = 880 | char 43616 43647 881 | 882 | 883 | {-| -} 884 | taiViet : Generator Char 885 | taiViet = 886 | char 43648 43743 887 | 888 | 889 | {-| -} 890 | meeteiMayekExtension : Generator Char 891 | meeteiMayekExtension = 892 | char 43744 43775 893 | 894 | 895 | {-| -} 896 | ethiopicExtendedA : Generator Char 897 | ethiopicExtendedA = 898 | char 43776 43823 899 | 900 | 901 | {-| -} 902 | meeteiMayek : Generator Char 903 | meeteiMayek = 904 | char 43968 44031 905 | 906 | 907 | {-| -} 908 | hangulSyllable : Generator Char 909 | hangulSyllable = 910 | char 44032 55215 911 | 912 | 913 | {-| -} 914 | hangulJamoExtendedB : Generator Char 915 | hangulJamoExtendedB = 916 | char 55216 55295 917 | 918 | 919 | {-| -} 920 | highSurrogate : Generator Char 921 | highSurrogate = 922 | char 55296 56191 923 | 924 | 925 | {-| -} 926 | highPrivateUseSurrogate : Generator Char 927 | highPrivateUseSurrogate = 928 | char 56192 56319 929 | 930 | 931 | {-| -} 932 | lowSurrogate : Generator Char 933 | lowSurrogate = 934 | char 56320 57343 935 | 936 | 937 | {-| -} 938 | privateUseArea : Generator Char 939 | privateUseArea = 940 | char 57344 63743 941 | 942 | 943 | {-| -} 944 | cjkCompatibilityIdeograph : Generator Char 945 | cjkCompatibilityIdeograph = 946 | char 63744 64255 947 | 948 | 949 | {-| -} 950 | alphabeticPresentationForm : Generator Char 951 | alphabeticPresentationForm = 952 | char 64256 64335 953 | 954 | 955 | {-| -} 956 | arabicPresentationFormA : Generator Char 957 | arabicPresentationFormA = 958 | char 64336 65023 959 | 960 | 961 | {-| -} 962 | variationSelector : Generator Char 963 | variationSelector = 964 | char 65024 65039 965 | 966 | 967 | {-| -} 968 | verticalForm : Generator Char 969 | verticalForm = 970 | char 65040 65055 971 | 972 | 973 | {-| -} 974 | combiningHalfMark : Generator Char 975 | combiningHalfMark = 976 | char 65056 65071 977 | 978 | 979 | {-| -} 980 | cjkCompatibilityForm : Generator Char 981 | cjkCompatibilityForm = 982 | char 65072 65103 983 | 984 | 985 | {-| -} 986 | smallFormVariant : Generator Char 987 | smallFormVariant = 988 | char 65104 65135 989 | 990 | 991 | {-| -} 992 | arabicPresentationFormB : Generator Char 993 | arabicPresentationFormB = 994 | char 65136 65279 995 | 996 | 997 | {-| -} 998 | halfwidthOrFullwidthForm : Generator Char 999 | halfwidthOrFullwidthForm = 1000 | char 65280 65519 1001 | 1002 | 1003 | {-| -} 1004 | special : Generator Char 1005 | special = 1006 | char 65520 65535 1007 | 1008 | 1009 | {-| -} 1010 | linearBSyllable : Generator Char 1011 | linearBSyllable = 1012 | char 65536 65663 1013 | 1014 | 1015 | {-| -} 1016 | linearBIdeogram : Generator Char 1017 | linearBIdeogram = 1018 | char 65664 65791 1019 | 1020 | 1021 | {-| -} 1022 | aegeanNumber : Generator Char 1023 | aegeanNumber = 1024 | char 65792 65855 1025 | 1026 | 1027 | {-| -} 1028 | ancientGreekNumber : Generator Char 1029 | ancientGreekNumber = 1030 | char 65856 65935 1031 | 1032 | 1033 | {-| -} 1034 | ancientSymbol : Generator Char 1035 | ancientSymbol = 1036 | char 65936 65999 1037 | 1038 | 1039 | {-| -} 1040 | phaistosDisc : Generator Char 1041 | phaistosDisc = 1042 | char 66000 66047 1043 | 1044 | 1045 | {-| -} 1046 | lycian : Generator Char 1047 | lycian = 1048 | char 66176 66207 1049 | 1050 | 1051 | {-| -} 1052 | carian : Generator Char 1053 | carian = 1054 | char 66208 66271 1055 | 1056 | 1057 | {-| -} 1058 | oldItalic : Generator Char 1059 | oldItalic = 1060 | char 66304 66351 1061 | 1062 | 1063 | {-| -} 1064 | gothic : Generator Char 1065 | gothic = 1066 | char 66352 66383 1067 | 1068 | 1069 | {-| -} 1070 | ugaritic : Generator Char 1071 | ugaritic = 1072 | char 66432 66463 1073 | 1074 | 1075 | {-| -} 1076 | oldPersian : Generator Char 1077 | oldPersian = 1078 | char 66464 66527 1079 | 1080 | 1081 | {-| -} 1082 | deseret : Generator Char 1083 | deseret = 1084 | char 66560 66639 1085 | 1086 | 1087 | {-| -} 1088 | shavian : Generator Char 1089 | shavian = 1090 | char 66640 66687 1091 | 1092 | 1093 | {-| -} 1094 | osmanya : Generator Char 1095 | osmanya = 1096 | char 66688 66735 1097 | 1098 | 1099 | {-| -} 1100 | cypriotSyllable : Generator Char 1101 | cypriotSyllable = 1102 | char 67584 67647 1103 | 1104 | 1105 | {-| -} 1106 | imperialAramaic : Generator Char 1107 | imperialAramaic = 1108 | char 67648 67679 1109 | 1110 | 1111 | {-| -} 1112 | phoenician : Generator Char 1113 | phoenician = 1114 | char 67840 67871 1115 | 1116 | 1117 | {-| -} 1118 | lydian : Generator Char 1119 | lydian = 1120 | char 67872 67903 1121 | 1122 | 1123 | {-| -} 1124 | meroiticHieroglyph : Generator Char 1125 | meroiticHieroglyph = 1126 | char 67968 67999 1127 | 1128 | 1129 | {-| -} 1130 | meroiticCursive : Generator Char 1131 | meroiticCursive = 1132 | char 68000 68095 1133 | 1134 | 1135 | {-| -} 1136 | kharoshthi : Generator Char 1137 | kharoshthi = 1138 | char 68096 68191 1139 | 1140 | 1141 | {-| -} 1142 | oldSouthArabian : Generator Char 1143 | oldSouthArabian = 1144 | char 68192 68223 1145 | 1146 | 1147 | {-| -} 1148 | avestan : Generator Char 1149 | avestan = 1150 | char 68352 68415 1151 | 1152 | 1153 | {-| -} 1154 | inscriptionalParthian : Generator Char 1155 | inscriptionalParthian = 1156 | char 68416 68447 1157 | 1158 | 1159 | {-| -} 1160 | inscriptionalPahlavi : Generator Char 1161 | inscriptionalPahlavi = 1162 | char 68448 68479 1163 | 1164 | 1165 | {-| -} 1166 | oldTurkic : Generator Char 1167 | oldTurkic = 1168 | char 68608 68687 1169 | 1170 | 1171 | {-| -} 1172 | rumiNumericalSymbol : Generator Char 1173 | rumiNumericalSymbol = 1174 | char 69216 69247 1175 | 1176 | 1177 | {-| -} 1178 | brahmi : Generator Char 1179 | brahmi = 1180 | char 69632 69759 1181 | 1182 | 1183 | {-| -} 1184 | kaithi : Generator Char 1185 | kaithi = 1186 | char 69760 69839 1187 | 1188 | 1189 | {-| -} 1190 | soraSompeng : Generator Char 1191 | soraSompeng = 1192 | char 69840 69887 1193 | 1194 | 1195 | {-| -} 1196 | chakma : Generator Char 1197 | chakma = 1198 | char 69888 69967 1199 | 1200 | 1201 | {-| -} 1202 | sharada : Generator Char 1203 | sharada = 1204 | char 70016 70111 1205 | 1206 | 1207 | {-| -} 1208 | takri : Generator Char 1209 | takri = 1210 | char 71296 71375 1211 | 1212 | 1213 | {-| -} 1214 | cuneiform : Generator Char 1215 | cuneiform = 1216 | char 73728 74751 1217 | 1218 | 1219 | {-| -} 1220 | cuneiformNumberOrPunctuation : Generator Char 1221 | cuneiformNumberOrPunctuation = 1222 | char 74752 74879 1223 | 1224 | 1225 | {-| -} 1226 | egyptianHieroglyph : Generator Char 1227 | egyptianHieroglyph = 1228 | char 77824 78895 1229 | 1230 | 1231 | {-| -} 1232 | bamumSupplement : Generator Char 1233 | bamumSupplement = 1234 | char 92160 92735 1235 | 1236 | 1237 | {-| -} 1238 | miao : Generator Char 1239 | miao = 1240 | char 93952 94111 1241 | 1242 | 1243 | {-| -} 1244 | kanaSupplement : Generator Char 1245 | kanaSupplement = 1246 | char 110592 110847 1247 | 1248 | 1249 | {-| -} 1250 | byzantineMusicalSymbol : Generator Char 1251 | byzantineMusicalSymbol = 1252 | char 118784 119039 1253 | 1254 | 1255 | {-| -} 1256 | musicalSymbol : Generator Char 1257 | musicalSymbol = 1258 | char 119040 119295 1259 | 1260 | 1261 | {-| -} 1262 | ancientGreekMusicalNotationSymbol : Generator Char 1263 | ancientGreekMusicalNotationSymbol = 1264 | char 119296 119375 1265 | 1266 | 1267 | {-| -} 1268 | taiXuanJingSymbol : Generator Char 1269 | taiXuanJingSymbol = 1270 | char 119552 119647 1271 | 1272 | 1273 | {-| -} 1274 | countingRodNumeral : Generator Char 1275 | countingRodNumeral = 1276 | char 119648 119679 1277 | 1278 | 1279 | {-| -} 1280 | mathematicalAlphanumericSymbol : Generator Char 1281 | mathematicalAlphanumericSymbol = 1282 | char 119808 120831 1283 | 1284 | 1285 | {-| -} 1286 | arabicMathematicalAlphabeticSymbol : Generator Char 1287 | arabicMathematicalAlphabeticSymbol = 1288 | char 126464 126719 1289 | 1290 | 1291 | {-| -} 1292 | mahjongTile : Generator Char 1293 | mahjongTile = 1294 | char 126976 127023 1295 | 1296 | 1297 | {-| -} 1298 | dominoTile : Generator Char 1299 | dominoTile = 1300 | char 127024 127135 1301 | 1302 | 1303 | {-| -} 1304 | playingCard : Generator Char 1305 | playingCard = 1306 | char 127136 127231 1307 | 1308 | 1309 | {-| -} 1310 | enclosedAlphanumericSupplement : Generator Char 1311 | enclosedAlphanumericSupplement = 1312 | char 127232 127487 1313 | 1314 | 1315 | {-| -} 1316 | enclosedIdeographicSupplement : Generator Char 1317 | enclosedIdeographicSupplement = 1318 | char 127488 127743 1319 | 1320 | 1321 | {-| -} 1322 | miscellaneousSymbolOrPictograph : Generator Char 1323 | miscellaneousSymbolOrPictograph = 1324 | char 127744 128511 1325 | 1326 | 1327 | {-| -} 1328 | emoticon : Generator Char 1329 | emoticon = 1330 | char 128512 128591 1331 | 1332 | 1333 | {-| -} 1334 | transportOrMapSymbol : Generator Char 1335 | transportOrMapSymbol = 1336 | char 128640 128767 1337 | 1338 | 1339 | {-| -} 1340 | alchemicalSymbol : Generator Char 1341 | alchemicalSymbol = 1342 | char 128768 128895 1343 | 1344 | 1345 | {-| -} 1346 | cjkUnifiedIdeographExtensionB : Generator Char 1347 | cjkUnifiedIdeographExtensionB = 1348 | char 131072 173791 1349 | 1350 | 1351 | {-| -} 1352 | cjkUnifiedIdeographExtensionC : Generator Char 1353 | cjkUnifiedIdeographExtensionC = 1354 | char 173824 177983 1355 | 1356 | 1357 | {-| -} 1358 | cjkUnifiedIdeographExtensionD : Generator Char 1359 | cjkUnifiedIdeographExtensionD = 1360 | char 177984 178207 1361 | 1362 | 1363 | {-| -} 1364 | cjkCompatibilityIdeographSupplement : Generator Char 1365 | cjkCompatibilityIdeographSupplement = 1366 | char 194560 195103 1367 | 1368 | 1369 | {-| -} 1370 | tag : Generator Char 1371 | tag = 1372 | char 917504 917631 1373 | 1374 | 1375 | {-| -} 1376 | variationSelectorSupplement : Generator Char 1377 | variationSelectorSupplement = 1378 | char 917760 917999 1379 | 1380 | 1381 | {-| -} 1382 | supplementaryPrivateUseAreaA : Generator Char 1383 | supplementaryPrivateUseAreaA = 1384 | char 983040 1048575 1385 | 1386 | 1387 | {-| -} 1388 | supplementaryPrivateUseAreaB : Generator Char 1389 | supplementaryPrivateUseAreaB = 1390 | char 1048576 1114111 1391 | --------------------------------------------------------------------------------