h$o[      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                          ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " # # # # # # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ % % % % % % % % % % % % % % % % % % % % % % % % % & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )))))))************************++++++++++++++++++++++++++++++++++++0 ASCII chars(c) Dong Han, 2020BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?.h0Z-Data \DEL1Z-Data ~2Z-Data }3Z-Data }4Z-Data |5Z-Data |6Z-Data {7Z-Data {RZ-Data `SZ-Data _TZ-Data ^UZ-Data ]VZ-Data ]WZ-Data \XZ-Data [YZ-Data [tZ-Data @uZ-Data ?vZ-Data >wZ-Data >xZ-Data =yZ-Data  \255.Z-Data \NUL <= w && w <= \DELZ-Data A ~ ZZ-Data a ~ zZ-DataA ~ Z => a ~ zZ-Dataa ~ z => A ~ ZZ-DataA ~ Z => a ~ z,  ~  =>  ~ ,  ~  =>  ~ Z-Dataa ~ z => A ~ Z,  ~  =>  ~ ,  ~  =>  ~ Z-Data ISO-8859-1 control letter.Z-Data ISO-8859-1 space letter.Z-Data 0 ~ 9Z-Data 0 ~ 7Z-Data 0 ~ 9, A ~ F, a ~ f0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210Primitive casting+Haskell Foundation, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?1<Z-Data* between primitive types of the same size.%unaligned access for primitive arrays(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?9Z-Databig endianess wrapperZ-Datalittle endianess wrapperZ-Data/Primitive types which can be unaligned accessedIt can also be used as a lightweight method to peek/poke value from/to C structs when you pass  to FFI as struct pointer, e.g.  -- | note the .hsc syntax peekSocketAddrMBA :: HasCallStack => MBA## SocketAddr -> IO SocketAddr peekSocketAddrMBA p = do family <- peekMBA p (#offset struct sockaddr, sa_family) case family :: CSaFamily of (#const AF_INET) -> do addr <- peekMBA p (#offset struct sockaddr_in, sin_addr) port <- peekMBA p (#offset struct sockaddr_in, sin_port) return (SocketAddrInet (PortNumber port) addr) .... Z-Data byte sizeZ-Dataindex element off byte array with offset in bytes(maybe unaligned)Z-Dataread element from byte array with offset in bytes(maybe unaligned)Z-Datawrite element to byte array with offset in bytes(maybe unaligned)Z-DataIO version of ' but more convenient to write manually.Z-DataIO version of ' but more convenient to write manually.Z-Dataindex element off byte array with offset in bytes(maybe unaligned)Z-DataLifted version of Z-DataLifted version of Z-DataLifted version of Z-DataLifted version of Z-DataLifted version of Z-DataLifted version of Z-Data(Encode PrimArray elements in big endian.Z-Data(Decode PrimArray elements in big endian.Z-Data%Write a, b, c, d, e, f, g, h in orderZ-Data"Write a, b, c, d, e, f, g in orderZ-DataWrite a, b, c, d, e, f in orderZ-DataWrite a, b, c, d, e in orderZ-DataWrite a, b, c, d in orderZ-DataWrite a, b, c in orderZ-DataWrite a, b in orderZ-Data,Char's instance use 31bit wide char prim-op. unlifted primitve arrays(c) Dong Han, 2017-2020BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?CZ-DataArray holding  values.Z-DataMutable array holding  values.Z-Data Types with  %, which can be stored / retrieved in .Z-DataCreates a new . This function is unsafe because it initializes all elements of the array as pointers to the array itself. Attempting to read one of these elements before writing to it is in effect an unsafe coercion from the  s a to the element type.Z-DataCreates a new  with the specified value as initial contents. This is slower than  , but safer.Z-DataYields the length of an .Z-DataYields the length of a .Z-Data Freezes a , yielding an . This simply marks the array as frozen in place, so it should only be used when no further modifications to the mutable array will be performed.Z-DataDetermines whether two  values are the same. This is object/pointer identity, not based on the contents.Z-Data?Copies the contents of an immutable array into a mutable array.Z-Data6Copies the contents of one mutable array into another.Z-DataFreezes a portion of a , yielding an . This operation is safe, in that it copies the frozen portion, and the existing mutable array may still be used afterward.Z-DataThaws a portion of an  , yielding a . This copies the thawed portion, so mutations will not affect the original array.Z-Data"Creates a copy of a portion of an Z-DataCreates a new : containing a copy of a portion of another mutable array. Z-DatasizeZ-DatasizeZ-Data initial valueZ-Data destinationZ-DataoffsetZ-DatalengthZ-Datavalue to fill withZ-Data destinationZ-Dataoffset into destinationZ-DatasourceZ-Dataoffset into sourceZ-Datanumber of elements to copyZ-Data destinationZ-Dataoffset into destinationZ-DatasourceZ-Dataoffset into sourceZ-Datanumber of elements to copyZ-DatasourceZ-DataoffsetZ-DatalengthZ-DatasourceZ-DataoffsetZ-DatalengthZ-DatasourceZ-DataoffsetZ-DatalengthZ-DatasourceZ-DataoffsetZ-DatalengthFast boxed and unboxed arrays(c) Dong Han, 2017BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?^!Z-DataThe typeclass that unifies box & unboxed and mutable & immutable array operations.Most of these functions simply wrap their primitive counterpart. When there are no primitive ones, we fulfilled the semantic with other operations.One exception is ) which only performs closure resizing on ., because currently, RTS only supports that. ( won't do anything on other array types.It's reasonable to trust GHC to specialize & inline these polymorphic functions. They are used across this package and perform identically to their monomorphic counterpart.Z-Data'The mutable version of this array type.Z-Data#Make a new array with a given size.#For boxed arrays, all elements are  , which shall not be accessed. For primitive arrays, elements are just random garbage.Z-Data3Make a new array and fill it with an initial value.Z-DataRead from specified index of mutable array in a primitive monad.Z-Data?Write to specified index of mutable array in a primitive monad.Z-Data*Fill the mutable array with a given value.Z-DataRead from the specified index of an immutable array. It's pure and often results in an indexing thunk for lifted arrays, use 'indexArr'' or  to avoid this.Z-DataRead from the specified index of an immutable array. The result is packaged into an unboxed unary tuple; the result itself is not yet evaluated. Pattern matching on the tuple forces the indexing of the array to happen but does not evaluate the element itself. Evaluating the thunk prevents additional thunks from building up on the heap. Avoiding these thunks, in turn, reduces references to the argument array, allowing it to be garbage collected more promptly.Z-DataMonadically read a value from the immutable array at the given index. This allows us to be strict in the array while remaining lazy in the read element which is very useful for collective operations. Suppose we want to copy an array. We could do something like this: copy marr arr ... = do ... writeArray marr i (indexArray arr i) ... ...2But since primitive arrays are lazy, the calls to ! will not be evaluated. Rather, marr will be filled with thunks each of which would retain a reference to arr&. This is definitely not what we want!With , we can instead write copy marr arr ... = do ... x <- indexArrayM arr i writeArray marr i x ...Now, indexing is executed immediately although the returned element is still not evaluated.Note:+ this function does not do bounds checking.Z-DataCreate an immutable copy of a slice of an array. This operation makes a copy of the specified section, so it is safe to continue using the mutable array afterward.Z-DataCreate a mutable array from a slice of an immutable array. This operation makes a copy of the specified slice, so it is safe to use the immutable array afterward.Z-DataConvert a mutable array to an immutable one without copying. The array should not be modified after the conversion.Z-DataConvert a mutable array to an immutable one without copying. The array should not be modified after the conversion.Z-DataCopy a slice of an immutable array to a mutable array at given offset.Z-DataCopy a slice of a mutable array to another mutable array at given offset. The two mutable arrays must not be the same.Z-DataCopy a slice of a mutable array to a mutable array at given offset. The two mutable arrays can be the same.Z-DataCreate an immutable copy with the given subrange of the original array.Z-Data?Create a mutable copy the given subrange of the original array.Z-Data)Resize a mutable array to the given size.Z-DataShrink a mutable array to the given size. This operation only works on primitive arrays. For some array types, this is a no-op, e.g. sizeOfMutableArr will not change.Z-Data)Is two mutable array are reference equal.Z-DataSize of the immutable array.Z-DataSize of the mutable array.Z-DataCheck whether the two immutable arrays refer to the same memory blockNote that the result of  may change depending on compiler's optimizations, for example, let arr = runST ... in arr  arr4 may return false if compiler decides to inline it.See  -https://ghc.haskell.org/trac/ghc/ticket/13908 for more context.Z-DataBottom value (throw ( ,-)) for new boxed array(+, &..) initialization.Z-DataObtain the pointer to the content of an array, and the pointer should only be used during the IO action.This operation is only safe on pinned' primitive arrays (Arrays allocated by  or ).0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-DataObtain the pointer to the content of an mutable array, and the pointer should only be used during the IO action.This operation is only safe on pinned' primitive arrays (Arrays allocated by  or ).0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-DataCast between arraysZ-DataCast between mutable arraysZ-DataModify(strictly) an immutable some elements of an array with specified subrange. This function will produce a new array.Z-DataInsert a value to an immutable array at given index. This function will produce a new array.Z-DataDelete an element of the immutable array's at given index. This function will produce a new array.Z-DatatargetZ-Dataoffset into target arrayZ-DatasourceZ-Dataoffset into source arrayZ-Datanumber of elements to copyZ-DatatargetZ-Dataoffset into target arrayZ-DatasourceZ-Dataoffset into source arrayZ-Datanumber of elements to copyZ-DatatargetZ-Dataoffset into target arrayZ-DatasourceZ-Dataoffset into source arrayZ-Datanumber of elements to copyZ-DataoffsetZ-DatalengthZ-Dataindex in new arrayZ-Datamodify functionZ-DataoffsetZ-DatalengthZ-Datainsert index in new arrayZ-Datavalue to be insertedZ-DataoffsetZ-DatalengthZ-Data"the index of the element to delete $#"! &%('+*).-,+*).-,&%('$#"!    *Extra stuff for PrimArray related literals(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?gZ-Data $[arrASCII|asdfg|] :: PrimArray Word8Z-Data*Construct data with UTF8 encoded literals.See Z-Data#Construct data with array literals  e.g. 1,2,3.Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data %[arrW8|1,2,3,4,5|] :: PrimArray Word8Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data $[arrW8|1,2,3,4,5|] :: PrimArray Int8Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data '[arrW16|1,2,3,4,5|] :: PrimArray Word16Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data &[arrI16|1,2,3,4,5|] :: PrimArray Int16Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data '[arrW32|1,2,3,4,5|] :: PrimArray Word32Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data &[arrI32|1,2,3,4,5|] :: PrimArray Int32Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data '[arrW64|1,2,3,4,5|] :: PrimArray Word64Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data &[arrI64|1,2,3,4,5|] :: PrimArray Int64Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data Construct   with array literals  e.g. 1,2,3. See Z-Data &[arrWord|1,2,3,4,5|] :: PrimArray WordZ-Data $[arrInt|1,2,3,4,5|] :: PrimArray IntZ-Data5Construction function which receive a byte length  and a   expression.Z-Data Quoter inputZ-Data Final Quoter"" (Bounded checked boxed and unboxed arrays(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?l:Z-Data.New size should be >= 0, and <= original size.Z-Data Create a pinned byte array of the specified size, The garbage collector is guaranteed not to move it.Z-Data Create a pinned primitive array of the specified size and respect given primitive type's alignment. The garbage collector is guaranteed not to move it.Z-DataInsert an immutable array's element at given index to produce a new array.Z-DataDrop an immutable array's element at given index to produce a new array.Z-DataoffsetZ-DatalengthZ-Dataindex in new arrayZ-Datamodify functionZ-DataoffsetZ-DatalengthZ-Datainsert index in new arrayZ-Dataelement to be insertedZ-DataoffsetZ-DatalengthZ-Datadrop index in new array $#"! &%('+*).-,+*).-,&%('$#"!   Numeric to ASCII digits table.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone+  #$&-./289:<>?n 0Compute Generic product size during compile time(c) Dong Han, 2017-2020BSDwinterland1989@gmail.com experimental non-portableNone-  #$&-./289:<>?o0Z-Data(type class for calculating product size.Primitive ST Reference(c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNone,  #$&-./289:<>?qDZ-DataA mutable variable in the ST monad which can hold an instance of $.Z-Data Build a new Z-DataRead the value of an Z-DataWrite a new value into an Z-DataMutate the contents of an .8Unboxed reference is always strict on the value it hold.Primitive IO Reference(c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNone,  #$&-./289:<>?wZ-DataAlias for 'PrimIORef Int' which support several atomic operations.Z-DataA mutable variable in the IO monad which can hold an instance of $.Z-Data Build a new Z-DataRead the value of an Z-DataWrite a new value into an Z-DataMutate the contents of an IORef.8Unboxed reference is always strict on the value it hold.Z-Data Build a new Z-DataAtomically add a , return the value AFTER added.Z-DataAtomically add a  , return the value BEFORE added.Z-DataAtomically add a .Z-DataAtomically sub a  , return the value AFTER subbed.Z-DataAtomically sub a !, return the value BEFORE subbed.Z-DataAtomically sub a Z-DataAtomically and a , return the value AFTER anded.Z-DataAtomically and a  , return the value BEFORE anded.Z-DataAtomically and a Z-DataAtomically nand a  , return the value AFTER nanded.Z-DataAtomically nand a !, return the value BEFORE nanded.Z-DataAtomically nand a Z-DataAtomically or a , return the value AFTER ored.Z-DataAtomically or a , return the value BEFORE ored.Z-DataAtomically or a Z-DataAtomically xor a , return the value AFTER xored.Z-DataAtomically xor a  , return the value BEFORE xored.Z-DataAtomically xor a .(c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNone,  #$&-./289:<>?yUTF-8 codecs and helpers.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?Z-Data,Return a codepoint's encoded length in bytesIf the codepoint is invalid, we return 3(encoded bytes length of replacement char U+FFFD).Z-Data Encode a  into bytes, write  for invalid unicode codepoint.This function assumed there're enough space for encoded bytes, and return the advanced index.Z-DataThe unboxed version of .This function is marked as NOINLINE to reduce code size, and stop messing up simplifier due to too much branches.Z-Data Encode a 5 into bytes with non-standard UTF-8 encoding(Used in  Data.CBytes).\NUL is encoded as two bytes C0 80 , \xD800 ~ \xDFFF is encoded as a three bytes normal UTF-8 codepoint. This function assumed there're enough space for encoded bytes, and return the advanced index.Z-DataThe unboxed version of .Z-Data Decode a  from bytesThis function assumed all bytes are UTF-8 encoded, and the index param point to the beginning of a codepoint, the decoded character and the advancing offset are returned.It's annoying to use unboxed tuple here but we really don't want allocation even if GHC can't optimize it away.Z-DataThe unboxed version of This function is marked as NOINLINE to reduce code size, and stop messing up simplifier due to too much branches.Z-Data$Decode a codepoint's length in bytesThis function assumed all bytes are UTF-8 encoded, and the index param point to the beginning of a codepoint.Z-DataThe unboxed version of This function is marked as NOINLINE to reduce code size, and stop messing up simplifier due to too much branches.Z-Data Decode a  from bytes in rerverse order.This function assumed all bytes are UTF-8 encoded, and the index param point to the end of a codepoint, the decoded character and the backward advancing offset are returned.Z-DataThe unboxed version of This function is marked as NOINLINE to reduce code size, and stop messing up simplifier due to too much branches.Z-Data6Decode a codepoint's length in bytes in reverse order.This function assumed all bytes are UTF-8 encoded, and the index param point to the end of a codepoint.Z-DataThe unboxed version of This function is marked as NOINLINE to reduce code size, and stop messing up simplifier due to too much branches.Z-DataUnrolled copy loop for copying a utf8-encoded codepoint from source array to target array.Z-DataUnrolled copy loop for copying a utf8-encoded codepoint from source array to target array.Z-DataxFFFD, which will be encoded as 0xEF 0xBF 0xBD 3 bytes.Errno provided by libuv(c) Winterland, 2017-2018BSDdrkoster@qq.com experimental non-portableNone,  #$&-./289:<>?Z-DataUnicode categories.See /-, you can combine categories with bitwise or.Z-Data*These are the Unicode Normalization Forms: Form | Description ---------------------------- | --------------------------------------------- Normalization Form D (NFD) | Canonical decomposition Normalization Form C (NFC) | Canonical decomposition, followed by canonical composition Normalization Form KD (NFKD) | Compatibility decomposition Normalization Form KC (NFKC) | Compatibility decomposition, followed by canonical composition Z-DataLocale for case mapping.Z-DataGet environment localeFast boxed and unboxed vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-Data$All exception can be throw by using .Z-DataPair type to help GHC unpack in some loops, useful when write fast folds.Z-Data! is just primitive word8 vectors.Z-DataPrimitive vectorZ-Data Boxed vectorZ-DataTypeclass for box and unboxed vectors, which are created by slicing arrays.Instead of providing a generalized vector with polymorphric array field, we use this typeclass so that instances use concrete array type can unpack their array payload.Vector types, e.g. ,&... are obivious instances, with O(1)  and , which convert slices to (array, offset, length) tuple back and forth.6Array types can also be instances of this class, e.g. +, ..., in this case 9 will always return offset 0 and whole array length, and  is O(n) .Z-DataVector's immutable array typeZ-Data7Get underline array and slice range(offset and length).Z-Data if x <= 5 then Just (x, x + 1) else Nothing) 0 == pack [0, 1, 2, 3, 4, 5]Z-DataO(n) Like ,  builds a vector from a seed value. However, the length of the result is limited by the first argument to (. This function is more efficient than 1 when the maximum length of the result is known.The following equation relates  and : ,fst (unfoldrN n f s) == take n (unfoldr f s)Z-DataO(n) * test if given element is in given vector.Z-DataO(n) 'not . elem'Z-DataO(n) The  function returns the index of the first element in the given vector which is equal to the query element, or  if there is no such element.Z-DataUnlike . instance, this mapping evaluate value inside  strictly.Z-Data.The chunk size used for I/O. Currently set to 16k - chunkOverheadZ-Data-The recommended chunk size. Currently set to 4k - chunkOverhead.Z-DataThe memory management overhead. Currently this is tuned for GHC only.Z-DatadefaultInitSize = 30<, used as initialize size when packing list of unknown size.Z-DataCast between vectorsZ-DataThis instance use , which may silently chop bytes, use it with ASCII literals only.Z-Data(This instance assume ASCII encoded bytesZ-Data=This is an INCOHERENT instance, hash binary data using FNV-1aNote this is different from  Vector Word8 or [Word8] which use FNV-1.Z-Data?This is an INCOHERENT instance, compare binary data using SIMD.Z-DatapayloadZ-Data1offset in elements of type a rather than in bytesZ-Data1length in elements of type a rather than in bytesZ-DatapayloadZ-DataoffsetZ-DatalengthZ-Datalength in elements of type aZ-Datainitialization functionZ-Datalength in elements of type aZ-Datainitialization function return a result size and array, the result must start from index 0Z-Datainitialization functionZ-Datainitialization functionZ-Datalength's upper boundZ-Data6initialization function which return the actual length!vectors literals using QuasiQuote(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?O  Searching vectors(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?Z-DataO(n) The  function extends , by returning the indices of all elements equal to the query element, in ascending order.Z-DataThe  function takes a predicate and a vector and returns the index of the first element in the vector satisfying the predicate.Z-DataO(n) Special  for  using  memchr(3)Z-Data findIndex f v = fst (find f v)Z-Data  findIndexR f v = fst (findR f v)Z-DataO(n) find the first index and element matching the predicate in a vector from left to right, if there isn't one, return (length of the vector, Nothing).Z-DataO(n) Special  for  using  memchr(3)Z-DataO(n) Find the first index and element matching the predicate in a vector from right to left, if there isn't one, return '(-1, Nothing)'.Z-DataO(n) Special  for  with memrchr.Z-DataO(n) , applied to a predicate and a vector, returns a vector containing those elements that satisfy the predicate.Z-DataO(n) The  function takes a predicate, a vector, returns a pair of vector with elements which do and do not satisfy the predicate, respectively; i.e., 4partition p vs == (filter p vs, filter (not . p) vs)Z-DataO(n+m); Find the offsets of all indices (possibly overlapping) of needle within haystack using KMP algorithm.6The KMP algorithm need pre-calculate a shift table in O(m)4 time and space, the worst case time complexity is O(n+m). Partial apply this function to reuse pre-calculated table between same needles.Chunked input are support via partial match argument, if set we will return an extra negative index in case of partial match at the end of input chunk, e.g. indicesOverlapping [ascii|ada|] [ascii|adadad|] True == [0,2,-2]Where -2) is the length of the partial match part ad 's negation.If an empty pattern is supplied, we will return every possible index of haystack, e.g. %indicesOverlapping "" "abc" = [0,1,2] References:Knuth, Donald; Morris, James H.; Pratt, Vaughan: "Fast pattern matching in strings" (1977) http://www-igm.univ-mlv.fr/~lecroq/string/node8.html#SECTION0080Z-DataO(n/m); Find the offsets of all indices (possibly overlapping) of needle within haystack using KMP algorithm, combined with simplified sunday's rule to obtain O(n/m) complexity in average use case.9The hybrid algorithm need pre-calculate a shift table in O(m)6 time and space, and a bad character bloom filter in O(m) time and O(1)+ space, the worst case time complexity is O(n+m). References:Frantisek FranekChristopher G. JenningsWilliam F. Smyth A Simple Fast Hybrid Pattern-Matching Algorithm (2005)D. M. Sunday: A Very Fast Substring Search Algorithm. Communications of the ACM, 33, 8, 132-142 (1990)%F. Lundh: The Fast Search Algorithm.  $http://effbot.org/zone/stringlib.htm (2006)Z-DataO(n+m)4 Find the offsets of all non-overlapping indices of needle within haystack using KMP algorithm.If an empty pattern is supplied, we will return every possible index of haystack, e.g. %indicesOverlapping "" "abc" = [0,1,2]Z-DataO(n/m)4 Find the offsets of all non-overlapping indices of needle within haystack using KMP algorithm, combined with simplified sunday's rule to obtain O(m/n) complexity in average use case.Z-DataO(m)$ Calculate the KMP next shift table./The shifting rules is: when a mismatch between  needle[j] and  haystack[i] is found, check if  next[j] == -1", if so next search continue with  needle[0] and  haystack[i+1], otherwise continue with needle[next[j]] and  haystack[i].Z-DataO(m)> Calculate a simple bloom filter for simplified sunday's rule./The shifting rules is: when a mismatch between  needle[j] and  haystack[i] is found, check if %elemSundayBloom bloom haystack[i+n-j], where n is the length of needle, if not then next search can be safely continued with haystack[i+n-j+1] and  needle[0]-, otherwise next searh should continue with  haystack[i] and  needle[0]2, or fallback to other shifting rules such as KMP.*The algorithm is very simple: for a given  w, we set the bloom's bit at unsafeShiftL 0x01 (w .&. 0x3f), so there're three false positives per bit. This's particularly suitable for search UTF-8 bytes since the significant bits of a beginning byte is usually the same.Z-Data.O(1) Test if a bloom filter contain a certain .Z-Datavector to search for (needle)Z-Datavector to search in (haystack)Z-Data+report partial match at the end of haystackZ-Databytes to search for (needle)Z-Databytes to search in (haystack)Z-Data+report partial match at the end of haystackZ-Databytes to search for (needle)Z-Databytes to search in (haystack)Z-Data+report partial match at the end of haystackFast vector slice manipulation(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?Z-DataO(n)  is analogous to (:) for lists, but of different complexity, as it requires making a copy.Z-DataO(n)% Append a byte to the end of a vectorZ-DataO(1)/ Extract the head and tail of a vector, return  if it is empty.Z-DataO(1)/ Extract the init and last of a vector, return  if vector is empty.Z-DataO(1)' Extract the first element of a vector.Z-DataO(1)1 Extract the elements after the head of a vector.NOTE: 4 return empty vector in the case of an empty vector.Z-DataO(1)& Extract the last element of a vector.Z-DataO(1)- Extract the elements before of the last one.NOTE: 4 return empty vector in the case of an empty vector.Z-DataO(n)> Return all initial segments of the given vector, empty first.Z-DataO(n) Return all final segments of the given vector, whole vector first.Z-DataO(1)  n, applied to a vector xs, returns the prefix of xs of length n, or xs itself if n >  xs.Z-DataO(1)  n, applied to a vector xs, returns the suffix of xs of length n, or xs itself if n >  xs.Z-DataO(1)  n xs returns the suffix of xs after the first n elements, or [] if n >  xs.Z-DataO(1)  n xs returns the prefix of xs before the last n elements, or [] if n >  xs.Z-DataO(1)= Extract a sub-range vector with give start index and length.1This function is a total function just like 'take drop', index+length exceeds range will be ingored, e.g. slice 1 3 "hello" == "ell" slice -1 -1 "hello" == "" slice -2 2 "hello" == "" slice 2 10 "hello" == "llo" This holds for all x y: &slice x y vs == drop x . take (x+y) vsZ-DataO(1)  n xs is equivalent to ( n xs,  n xs).Z-DataO(n) Applied to a predicate p and a vector vs2, returns the longest prefix (possibly empty) of vs of elements that satisfy p.Z-DataO(n) Applied to a predicate p and a vector vs2, returns the longest suffix (possibly empty) of vs of elements that satisfy p.Z-DataO(n) Applied to a predicate p and a vector vs7, returns the suffix (possibly empty) remaining after  p vs.Z-DataO(n) Applied to a predicate p and a vector vs8, returns the prefix (possibly empty) remaining before  p vs.Z-DataO(n) )dropAround f = dropWhile f . dropWhileR fZ-DataO(n) Split the vector into the longest prefix of elements that do not satisfy the predicate and the rest without copying. break (==x) will be rewritten using a memchr.Z-DataO(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying. span (/=x) will be rewritten using a memchr.Z-Data behaves like  but from the end of the vector. breakR p == spanR (not.p)Z-Data behaves like  but from the end of the vector.Z-DataBreak a vector on a subvector, returning a pair of the part of the vector prior to the match, and the rest of the vector, e.g. 1break "wor" "hello, world" = ("hello, ", "world")Z-DataO(n) The ( function takes two vectors and returns  the remainder of the second iff the first is its prefix, and otherwise .Z-DataThe isPrefix function returns 1 if the first argument is a prefix of the second.Z-DataO(n) Find the longest non-empty common prefix of two strings and return it, along with the suffixes of each string at which they no longer match. e.g.commonPrefix "foobar" "fooquux"("foo","bar","quux")commonPrefix "veeble" "fetzer"("","veeble","fetzer")Z-Data O(n) The  function takes two vectors and returns Just the remainder of the second iff the first is its suffix, and otherwise Nothing.Z-DataO(n) The ( function takes two vectors and returns ) if the first is a suffix of the second.Z-Data3Check whether one vector is a subvector of another.needle < haystack === null haystack || indices needle haystake /= [].Z-DataO(n) Break a vector into pieces separated by the delimiter element consuming the delimiter. I.e. split '\n' "a\nb\nd\ne" == ["a","b","d","e"] split 'a' "aXaXaXa" == ["","X","X","X",""] split 'x' "x" == ["",""]and 9intercalate [c] . split c == id split == splitWith . (==)?NOTE, this function behavior different with bytestring's. see  /https://github.com/haskell/bytestring/issues/56#56.Z-DataO(m+n)0 Break haystack into pieces separated by needle.Note: An empty needle will essentially split haystack element by element. Examples:!splitOn "\r\n" "a\r\nb\r\nd\r\ne"["a","b","d","e"] splitOn "aaa" "aaaXaaaXaaaXaaa"["","X","X","X",""]splitOn "x" "x"["",""]and intercalate s . splitOn s == id splitOn (singleton c) == split (==c)Z-DataO(n) Splits a vector into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg. splitWith (=='a') "aabbaca" == ["","","bb","c",""] splitWith (=='a') [] == [""]?NOTE, this function behavior different with bytestring's. see  /https://github.com/haskell/bytestring/issues/56#56.Z-DataO(n) Breaks a 3 up into a list of words, delimited by ascii space.Z-DataO(n) Breaks a - up into a list of lines, delimited by ascii n1, The resulting strings do not contain newlines. Note that it does not regard CR ('\r') as a newline character.Z-DataO(n) Joins words with ascii space.Z-DataO(n) Joins lines with ascii n.'NOTE: This functions is different from 01, it DOES NOT add a trailing n.Z-DataAdd padding to the left so that the whole vector's length is at least n.Z-DataAdd padding to the right so that the whole vector's length is at least n.Z-DataO(n)  vs% efficiently returns the elements of xs in reverse order.Z-DataO(n) The  function takes an element and a vector and `intersperses' that element between the elements of the vector. It is analogous to the intersperse function on Lists.Z-DataO(n) The  function takes a vector and a list of vectors and concatenates the list after interspersing the first argument between each element of the list.Note: # will force the entire vector list.Z-DataO(n)1 An efficient way to join vector with an element.Z-DataThe  function transposes the rows and columns of its vector argument.Z-Data( zip two vector with a zipping function. For example,  (+) is applied to two vector to produce a vector of corresponding sums, the result will be evaluated strictly.Z-Data4 disassemble a vector with a disassembling function,4The results inside tuple will be evaluated strictly.Z-Data is similar to foldl, but returns a list of successive reduced values from the left. scanl' f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that -lastM (scanl' f z xs) == Just (foldl f z xs).Z-Data'scanl1'' is a variant of % that has no starting value argument. scanl1' f [x1, x2, ...] == [x1, x1 `f` x2, ...] scanl1' f [] == []Z-Data+scanr' is the right-to-left dual of scanl'.Z-Data is a variant of % that has no starting value argument.Z-Datax' = rangeCut x min max limit x' 's range to min ~ max.Z-DataO(1)' Extract the first element of a vector.Throw  if vector is empty.Z-DataO(1)1 Extract the elements after the head of a vector.Throw  if vector is empty.Z-DataO(1)- Extract the elements before of the last one.Throw  if vector is empty.Z-DataO(1)& Extract the last element of a vector.Throw  if vector is empty.Z-DataO(1) Index array element.Throw  if index outside of the vector.Z-DataO(1) Index array element.Throw  if index outside of the vector.Z-DataO(n)+ Modify vector's element under given index.Throw  if index outside of the vector.Z-DataO(n)+ Modify vector's element under given index.6Return original vector if index outside of the vector.Z-DataO(n), insert element to vector under given index.Throw  if index outside of the vector.Z-DataO(n), insert element to vector under given index.6Return original vector if index outside of the vector.Z-DataO(n)+ Delete vector's element under given index.Throw  if index outside of the vector.Z-DataO(n)+ Delete vector's element under given index.6Return original vector if index outside of the vector.Z-DataO(1)' Extract the first element of a vector.Make sure vector is non-empty, otherwise segmentation fault await!Z-DataO(1)1 Extract the elements after the head of a vector.Make sure vector is non-empty, otherwise segmentation fault await!Z-DataO(1)- Extract the elements before of the last one.Make sure vector is non-empty, otherwise segmentation fault await!Z-DataO(1)& Extract the last element of a vector.Make sure vector is non-empty, otherwise segmentation fault await!Z-DataO(1) Index array element.Make sure index is in bound, otherwise segmentation fault await!Z-DataO(1) Index array element.Make sure index is in bound, otherwise segmentation fault await!Z-DataO(n)+ Modify vector's element under given index.Make sure index is in bound, otherwise segmentation fault await!Z-DataO(n), Insert element to vector under given index.Make sure index is in bound, otherwise segmentation fault await!Z-DataO(n)+ Delete vector's element under given index.Make sure index is in bound, otherwise segmentation fault await!Z-DataO(1)  n, applied to a vector xs, returns the prefix of xs of length n.Make sure n is smaller than vector's length, otherwise segmentation fault await!Z-DataO(1)  n xs returns the suffix of xs after the first n elements.Make sure n is smaller than vector's length, otherwise segmentation fault await!Z-Dataslice beginning indexZ-Data slice lengthZ-Datathe prefix to be testedZ-Datathe prefix to be testedUnicode text processing(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?1{;Z-Data#first payload is invalid char indexZ-Data represented as UTF-8 encoded Z-DataExtract UTF-8 encoded  from Z-DataO(n) Get the nth codepoint from , throw  when out of bound.Z-DataO(n) Get the nth codepoint from .Z-DataO(n) Find the nth codepoint's byte index (pointing to the nth char's begining byte).The index is only meaningful to the whole byte slice, if there's less than n codepoints, the index will point to next byte after the end.Z-DataO(n) Get the nth codepoint from  counting from the end, throw !IndexOutOfVectorRange n callStack when out of bound.Z-DataO(n) Get the nth codepoint from  counting from the end.Z-DataO(n) Find the nth codepoint's byte index from the end (pointing to the previous char's ending byte).The index is only meaningful to the whole byte slice, if there's less than n codepoints, the index will point to previous byte before the start.Z-DataO(n)/ Validate a sequence of bytes is UTF-8 encoded.Throw  in case of invalid codepoint.Z-DataO(n)/ Validate a sequence of bytes is UTF-8 encoded.Return  in case of invalid codepoint.Z-DataO(n); Validate a sequence of bytes is all ascii char byte(<128).Throw 7 in case of invalid byte, It's not always faster than ;, use it only if you want to validate ASCII char sequences.Z-DataO(n); Validate a sequence of bytes is all ascii char byte(<128).Return  in case of invalid byte.Z-DataO(n) Convert a string into a text Alias for  defaultInitSize,, will be rewritten to a memcpy if possible.Z-DataO(n) Convert a list into a text with an approximate size(in bytes, not codepoints).If the encoded bytes length is larger than the size given, we simply double the buffer size and continue building.This function is a  good consumer$ in the sense of build/foldr fusion.Z-DataO(n) Alias for  defaultInitSize.Z-DataO(n)  in reverse order.This function is a  good consumer$ in the sense of build/foldr fusion.Z-DataO(n) Convert text to a char list.Unpacking is done lazily. i.e. we will retain reference to the array until all element are consumed.This function is a  good producer$ in the sense of build/foldr fusion.Z-DataO(n)) Convert text to a list in reverse order.This function is a  good producer$ in the sense of build/foldr fusion.Z-DataO(1). Single char text.Z-DataO(1) . Empty text.Z-DataO(n). Copy a text from slice.Z-DataO(m+n)There's no need to guard empty vector because we guard them for you, so appending empty text are no-ops.Z-DataO(1) Test whether a text is empty.Z-DataO(n) The char length of a text.Z-DataO(n) map f t is the  obtained by applying f to each char of t0. Performs replacement on invalid scalar values.Z-DataStrict mapping with index.Z-DataStrict left to right fold.Z-Data%Strict left to right fold with index.Z-DataStrict right to left foldZ-Data$Strict right to left fold with index1NOTE: the index is counting from 0, not backwardsZ-DataO(n) Concatenate a list of text.Note:  have to force the entire list to filter out empty text and calculate the length for allocation.Z-Data6Map a function over a text and concatenate the resultsZ-DataO(n) ) returns count of an element from a text.Z-DataO(n)$ Applied to a predicate and a text, < determines if any chars of the text satisfy the predicate.Z-DataO(n)" Applied to a predicate and text, < determines if all chars of the text satisfy the predicate.Z-DataO(n)  char n time.Z-DataO(n*m)  a text n times.Z-DataO(n) convert from a char vector.Z-DataO(n) convert to a char vector.Z-Data>Check if a string is stable in the NFC (Normalization Form C).Z-DataCheck if a string is stable in the specified Unicode Normalization Form.This function can be used as a preprocessing step, before attempting to normalize a string. Normalization is a very expensive process, it is often cheaper to first determine if the string is unstable in the requested normalization form.The result of the check will be YES if the string is stable and MAYBE or NO if it is unstable. If the result is MAYBE, the string does not necessarily have to be normalized.%For more information, please review < $http://www.unicode.org/reports/tr15/; Unicode Standard Annex #15 - Unicode Normalization Forms>.Z-Data1Normalize a string to NFC (Normalization Form C).Z-Data?Normalize a string to the specified Unicode Normalization Form.The Unicode standard defines two standards for equivalence between characters: canonical and compatibility equivalence. Canonically equivalent characters and sequence represent the same abstract character and must be rendered with the same appearance and behavior. Compatibility equivalent characters have a weaker equivalence and may be rendered differently.Unicode Normalization Forms are formally defined standards that can be used to test whether any two strings of characters are equivalent to each other. This equivalence may be canonical or compatibility.The algorithm puts all combining marks into a specified order and uses the rules for decomposition and composition to transform the string into one of four Unicode Normalization Forms. A binary comparison can then be used to determine equivalence.Z-DataRemove case distinction from UTF-8 encoded text with default locale.Z-Data0Remove case distinction from UTF-8 encoded text.Case folding is the process of eliminating differences between code points concerning case mapping. It is most commonly used for comparing strings in a case-insensitive manner. Conversion is fully compliant with the Unicode 7.0 standard.Although similar to lowercasing text, there are significant differences. For one, case folding does _not_ take locale into account when converting. In some cases, case folding can be up to 20% faster than lowercasing the same text, but the result cannot be treated as correct lowercased text.Only two locale-specific exception are made when case folding text. In Turkish, U+0049 LATIN CAPITAL LETTER I maps to U+0131 LATIN SMALL LETTER DOTLESS I and U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE maps to U+0069 LATIN SMALL LETTER I.Although most code points can be case folded without changing length, there are notable exceptions. For example, U+0130 (LATIN CAPITAL LETTER I WITH DOT ABOVE) maps to "U+0069 U+0307" (LATIN SMALL LETTER I and COMBINING DOT ABOVE) when converted to lowercase.Only a handful of scripts make a distinction between upper- and lowercase. In addition to modern scripts, such as Latin, Greek, Armenian and Cyrillic, a few historic or archaic scripts have case. The vast majority of scripts do not have case distinctions.Z-Data?9 Z-Data+find all char index matching the predicate.Z-Data2find all char's byte index matching the predicate.Z-DataO(n) find the first char matching the predicate in a text from left to right, if there isn't one, return the text length.Z-DataO(n) find the first char matching the predicate in a text from right to left.Z-DataO(n) find the char index.Z-DataO(n)& find the char index in reverse order.Z-DataO(n)" find the char's byte slice index.Z-DataO(n) find the char's byte slice index in reverse order(pointing to the right char's first byte).Z-DataO(n) , applied to a predicate and a text, returns a text containing those chars that satisfy the predicate.Z-DataO(n) The  function takes a predicate, a text, returns a pair of text with codepoints which do and do not satisfy the predicate, respectively; i.e., 7partition p txt == (filter p txt, filter (not . p) txt)Z-DataO(n) % test if given char is in given text.Z-DataO(n)  not . elemZ-Data(char index, matching char)Z-Data/(char index(counting backwards), matching char)  Fast text slice manipulation(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?Y<4Z-DataO(n)  is analogous to (:) for lists, but of different complexity, as it requires making a copy.Z-DataO(n)$ Append a char to the end of a text.Z-DataO(1)- Extract the head and tail of a text, return  if it is empty.Z-DataO(1)- Extract the init and last of a text, return  if text is empty.Z-DataO(1)" Extract the first char of a text.Throw  if text is empty.Z-DataO(1), Extract the chars after the head of a text.Throw  if text is empty.Z-DataO(1)! Extract the last char of a text.Throw  if text is empty.Z-DataO(1)* Extract the chars before of the last one.Throw  if text is empty.Z-DataO(1)" Extract the first char of a text.Z-DataO(1), Extract the chars after the head of a text.NOTE: 0 return empty text in the case of an empty text.Z-DataO(1)! Extract the last char of a text.Z-DataO(1)* Extract the chars before of the last one.NOTE: 0 return empty text in the case of an empty text.Z-DataO(n)< Return all initial segments of the given text, empty first.Z-DataO(n)? Return all final segments of the given text, whole text first.Z-DataO(1)  n, applied to a text xs, returns the prefix of xs of length n, or xs itself if n >  xs.Z-DataO(1)  n xs returns the suffix of xs after the first n char, or [] if n >  xs.Z-DataO(1)  n, applied to a text xs, returns the suffix of xs of length n, or xs itself if n >  xs.Z-DataO(1)  n xs returns the prefix of xs before the last n char, or [] if n >  xs.Z-DataO(1); Extract a sub-range text with give start index and length.1This function is a total function just like 'take drop', index+length exceeds range will be ingored, e.g. slice 1 3 "hello" == "ell" slice -1 -1 "hello" == "" slice -2 2 "hello" == "" slice 2 10 "hello" == "llo" This holds for all x y: &slice x y vs == drop x . take (x+y) vsZ-DataO(n)  n xs is equivalent to ( n xs,  n xs).Z-DataO(n) Applied to a predicate p and a text t2, returns the longest prefix (possibly empty) of t of elements that satisfy p.Z-DataO(n) Applied to a predicate p and a text t2, returns the longest suffix (possibly empty) of t of elements that satisfy p.Z-DataO(n) Applied to a predicate p and a text vs7, returns the suffix (possibly empty) remaining after  p vs.Z-DataO(n) Applied to a predicate p and a text vs8, returns the prefix (possibly empty) remaining before  p vs.Z-DataO(n) )dropAround f = dropWhile f . dropWhileR fZ-DataO(n) Split the text into the longest prefix of elements that do not satisfy the predicate and the rest without copying.Z-DataO(n) Split the text into the longest prefix of elements that satisfy the predicate and the rest without copying.Z-Data behaves like  but from the end of the text. breakR p == spanR (not.p)Z-Data behaves like  but from the end of the text.Z-DataBreak a text on a subtext, returning a pair of the part of the text prior to the match, and the rest of the text, e.g. 1break "wor" "hello, world" = ("hello, ", "world")Z-DataO(n+m) Find all non-overlapping instances of needle in haystack. Each element of the returned list consists of a pair::The entire string prior to the kth match (i.e. the prefix)6The kth match, followed by the remainder of the string Examples: &breakOnAll "::" "" ==> [] breakOnAll "" "abc" ==> [("a", "bc"), ("ab", "c"), ("ab c", "/")] The result list is lazy, search is performed when you force the list.Z-DataThe group function takes a text and returns a list of texts such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example, group  Mississippi = [M!,"i","ss","i","ss","i","pp","i"] It is a special case of , which allows the programmer to supply their own equality test.Z-DataThe + function is the non-overloaded version of .Z-DataO(n) The & function takes two texts and returns  the remainder of the second iff the first is its prefix, and otherwise .Z-Data O(n) The  function takes two texts and returns Just the remainder of the second iff the first is its suffix, and otherwise Nothing.Z-DataO(n) Break a text into pieces separated by the delimiter element consuming the delimiter. I.e. split '\n' "a\nb\nd\ne" == ["a","b","d","e"] split 'a' "aXaXaXa" == ["","X","X","X",""] split 'x' "x" == ["",""]and 9intercalate [c] . split c == id split == splitWith . (==)?NOTE, this function behavior different with bytestring's. see  /https://github.com/haskell/bytestring/issues/56#56.Z-DataO(n) Splits a text into components delimited by separators, where the predicate returns True for a separator char. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg. splitWith (=='a') "aabbaca" == ["","","bb","c",""] splitWith (=='a') [] == [""]Z-DataO(m+n)0 Break haystack into pieces separated by needle.Note: An empty needle will essentially split haystack element by element. Examples:!splitOn "\r\n" "a\r\nb\r\nd\r\ne"["a","b","d","e"] splitOn "aaa" "aaaXaaaXaaaXaaa"["","X","X","X",""]splitOn "x" "x"["",""]and intercalate s . splitOn s == id splitOn (singleton c) == split (==c)Z-DataThe isPrefix function returns 1 if the first argument is a prefix of the second.Z-DataO(n) The % function takes two text and returns ) if the first is a suffix of the second.Z-Data/Check whether one text is a subtext of another.needle < haystack === null haystack || indices needle haystake /= [].Z-DataO(n) Find the longest non-empty common prefix of two strings and return it, along with the suffixes of each string at which they no longer match. e.g.commonPrefix "foobar" "fooquux"("foo","bar","quux")commonPrefix "veeble" "fetzer"("","veeble","fetzer")Z-DataO(n) Breaks a Bytes5 up into a list of words, delimited by unicode space.Z-DataO(n); Breaks a text up into a list of lines, delimited by ascii n.Z-DataO(n) Joins words with ascii space.Z-DataO(n) Joins lines with ascii n.'NOTE: This functions is different from 01, it DOES NOT add a trailing n.Z-DataAdd padding to the left so that the whole text's length is at least n.Z-DataAdd padding to the right so that the whole text's length is at least n.Z-DataO(n) The  function takes a character and places it between the characters of a 0. Performs replacement on invalid scalar values.Z-DataO(n)$ Reverse the characters of a string.Z-DataO(n) The  function takes a  and a list of s and concatenates the list after interspersing the first argument between each element of the list.Z-DataThe  function transposes the rows and columns of its text argument.Z-Dataneedle to search forZ-Datahaystack in which to search55Efficient serialization/format.;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?q'Z-DataBuilder is a monad to help compose  BuilderStep . With next  BuilderStep continuation, we can do interesting things like perform some action, or interleave the build process. Notes on  instance:  Builder ()'s  instance use , which is different from / in that it DOES NOT PROVIDE UTF8 GUARANTEES! :\NUL will be written as  \xC0 \x80.\xD800 ~ \xDFFF; will be encoded in three bytes as normal UTF-8 codepoints.Z-Data BuildSignal&s abstract signals to the caller of a . There are three signals: , , or  signalsZ-Data BuilderStep7 is a function that fill buffer under given conditions.Z-DataHelper type to help ghc unpackZ-DataFreeze buffer and return a .4Note the mutable buffer array will be shrinked with #, which may not able to be reused.Z-DataEncode string with modified UTF-8 encoding, will be rewritten to a memcpy if possible.Z-DataTurn  into  with Modified UTF8 encoding\NUL is encoded as two bytes C0 80 , \xD800 ~ \xDFFF4 is encoded as a three bytes normal UTF-8 codepoint.Z-DataWrite a .Z-Data Shortcut to  .Z-Data1Build some bytes and validate if it's UTF8 bytes.Z-Data-Build some bytes assuming it's UTF8 encoding.Be carefully use this function because you could constrcut illegal  values. Check 23 for UTF8 encoding builders. This functions is intended to be used in debug only.Z-DataRun Builder with doubling buffer strategy, which is suitable for building short bytes.Z-Data Shortcut to  .Z-DataRun Builder with inserting chunk strategy, which is suitable for building a list of bytes chunks and processing them in a streaming ways.Note the building process is lazy, building happens when list chunks are consumed.Z-Data*Write a primitive type in host byte order. >> encodePrim (256 :: Word16, BE 256 :: BE Word16) > [0,1,1,0] Z-Data-Write a primitive type with little endianess.Z-Data*Write a primitive type with big endianess.Z-DataTurn  into  with UTF8 encoding&Illegal codepoints will be written as s. to original builder.Z-Dataadd "..." to original builder.Z-Dataadd '...' to original builder.Z-Datawrite an ASCII :Z-Datawrite an ASCII ,Z-Data.Use separator to connect a vector of builders. import Z.Data.Builder as B import Z.Data.Text as T import Z.Data.Vector as V > T.validate . B.build $ B.intercalateVec "," B.int (V.pack [1,2,3,4] :: V.PrimVector Int) "1,2,3,4" Z-Data*Use separator to connect list of builders. import Z.Data.Builder as B import Z.Data.Text as T import Z.Data.Vector as V T.validate . B.build $ B.intercalateList "," B.int ([1,2,3,4] :: [Int]) "1,2,3,4" Z-DataThis instance simple write literals' bytes into buffer, which is different from / in that it DOES NOT PROVIDE UTF8 GUARANTEES! :Z-Datathe buffer contentZ-Datawriting offsetZ-Data size boundZ-Data4the writer which return a new offset for next writeZ-Data size boundZ-Data'the writer should write exactly N bytesZ-Data the seperatorZ-Datavalue formatterZ-Data value vectorZ-Data the seperatorZ-Datavalue formatterZ-Data value list55Sorting vectors/(c) 2008-2011 Dan Doel, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?~1Z-Data Similar to   newtype for *, this newtype can inverse the order of a  instance when used in .Z-Data2Types contain radixs, which can be inspected with  during different .#The default instances share a same ' 256, which seems to be a good default.Z-Data8The size of an auxiliary array, i.e. the counting bucketZ-DataThe number of passes necessary to sort an array of es, it equals to the key's byte number.Z-DataThe radix function used in the first pass, works on the least significant bit.Z-DataThe radix function parameterized by the current pass (0 < pass < passes e-1).Z-DataThe radix function used in the last pass, works on the most significant bit.Z-Data O(n*log(n)) Sort vector based on element's  instance with classic  (https://en.wikipedia.org/wiki/Merge_sort mergesort algorithm.This is a stable sort, During sorting two O(n) worker arrays are needed, one of them will be freezed into the result vector. The merge sort only begin at tile size larger than  , each tile will be sorted with , then iteratively merged into larger array, until all elements are sorted.Z-DataThe mergesort tile size, mergeTileSize = 8.Z-DataO(n^2) Sort vector based on element's  instance with simple  ,https://en.wikipedia.org/wiki/Insertion_sortinsertion-sort algorithm.This is a stable sort. O(n) extra space are needed, which will be freezed into result vector.Z-DataO(n) Sort vector based on element's  instance with  (https://en.wikipedia.org/wiki/Radix_sort radix-sort3, (Least significant digit radix sorts variation).This is a stable sort, one or two extra O(n) worker array are need depend on how many  shall be performed, and a  counting bucket are also needed. This sort algorithms performed extremly well on small byte size types such as  or , while on larger type, constant passes may render this algorithm not suitable for small vectors (turning point around 2^(2*passes)).Z-Data7merge duplicated adjacent element, prefer left element.Use this function on a sorted vector will have the same effects as nub.Z-Data7Merge duplicated adjacent element, prefer left element.Z-Data8Merge duplicated adjacent element, prefer right element.Z-DataMerge duplicated adjacent element, based on a equality tester and a merger function.Z-Dataequality tester,  left right -> eq left rightZ-Dataequality tester,  left right -> eq left rightZ-Dataequality tester,  left right -> eq left rightZ-Data the merger,  left right -> merge left right  4Fast boxed and unboxed vector(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?H  #Use PrimArray / PrimVector with FFI(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?WZ-Data std::string Pointer tag.Z-DataType alias for .Describe a array of ; which we are going to pass across FFI. Use this type with UnliftedFFITypes& extension, At C side you should use  StgArrBytes** (>=8.10) or StgMutArrPtrs*8(<8.10) type from "Rts.h", example code modified from  https://downloads.haskell.org/ghc/latest/docs/html/users_guide/ffi-chap.html#unlifted-ffi-types GHC manual: // C source, must include the RTS to make the struct StgArrBytes // available along with its fields: ptrs and payload. #include "Rts.h" // GHC 8.10 changes the way how ArrayArray# is passed to C, so... #if __GLASGOW_HASKELL__ < 810 HsInt sum_first (StgMutArrPtrs *arr, HsInt len) { StgArrBytes **bufs = (StgArrBytes**)arr->payload; #else HsInt sum_first (StgArrBytes **bufs, HsInt len) { #endif int res = 0; for(StgWord ix = 0;ix < len;ix++) { // payload pointer type is StgWord*, cast it before use! res = res + ((HsInt*)(bufs[ix]->payload))[0]; } return res; } -- Haskell source, all elements in the argument array must be -- either ByteArray# or MutableByteArray#. This is not enforced -- by the type system in this example since ArrayArray is untyped. foreign import ccall unsafe "sum_first" sumFirst :: BAArray# Int -> Int -> IO CInt Z-DataType alias for  . Describe a ; which we are going to pass across FFI. Use this type with UnliftedFFITypes< extension, At C side you should use a proper pointer type. Don't cast  to  since the heap object offset is hard-coded in code generator: https://github.com/ghc/ghc/blob/master/compiler/GHC/StgToCmm/Foreign.hs#L5420Note [Unlifted boxed arguments to foreign calls]+USE THIS TYPE WITH UNSAFE FFI CALL ONLY. A + COULD BE MOVED BY GC DURING SAFE FFI CALL.Z-DataType alias for . Describe a ; which we are going to pass across FFI. Use this type with UnliftedFFITypes extension, At C side you should use a proper const pointer type. Don't cast  to  since the heap object offset is hard-coded in code generator: https://github.com/ghc/ghc/blob/master/compiler/GHC/StgToCmm/Foreign.hs#L5420Note [Unlifted boxed arguments to foreign calls]In haskell side we use type system to distinguish immutable / mutable arrays, but in C side we can't. So it's users' responsibility to make sure the array content is not mutated (a const pointer type may help).+USE THIS TYPE WITH UNSAFE FFI CALL ONLY. A + COULD BE MOVED BY GC DURING SAFE FFI CALL.Z-DataClear  with given length to zero.Z-Data.Pass primitive array to unsafe FFI as pointer.Enable UnliftedFFITypes= extension in your haskell code, use proper pointer type and HsInt to marshall  ByteArray# and Int arguments on C side. The second 2 arguement is the element size not the bytes size.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-Data+Pass primitive array list to unsafe FFI as  StgArrBytes**.Enable UnliftedFFITypes% extension in your haskell code, use  StgArrBytes** (>=8.10) or StgMutArrPtrs*(<8.10) pointer type and HsInt to marshall BAArray# and Int- arguments on C side, check the example with . The second  arguement is the list size.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-DataAllocate some bytes and pass to FFI as pointer, freeze result into a .,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-DataPass  to unsafe FFI as pointerThe  version of . The second 2 arguement is the first element offset, the third ! argument is the element length.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-DataAllocate a prim array and pass to FFI as pointer, freeze result into a .,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-DataAllocate some bytes and pass to FFI as pointer, freeze result into a .,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-DataCreate an one element primitive array and use it as a pointer to the primitive element..Return the element and the computation result.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-Datalike  , but don't write initial value.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-Data,Pass primitive array to safe FFI as pointer.Use proper pointer type and HsInt to marshall Ptr a and Int arguments on C side. The memory pointed by 'Ptr a' will not moved during call. After call returned, pointer is no longer valid. The second 2 arguement is the element size not the bytes size.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-Data1Pass primitive array list to safe FFI as pointer.Use proper pointer type and HsInt to marshall  Ptr (Ptr a) and Int arguments on C side. The memory pointed by 'Ptr a' will not moved during call. After call returned, pointer is no longer valid. The second  arguement is the list size.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-DataAllocate a prim array and pass to FFI as pointer, freeze result into a .Z-DataPass  to safe FFI as pointerThe  version of . The  is already pointed to the first element, thus no offset is provided. After call returned, pointer is no longer valid.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-DataCreate an one element primitive array and use it as a pointer to the primitive element.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-Datalike  , but don't write initial value.Z-DataAllocate a prim array and pass to FFI as pointer, freeze result into a .Z-DataAllocate some bytes and pass to FFI as pointer, freeze result into a .Z-Data Convert a 8 to a pinned one(memory won't moved by GC) if necessary.Z-Data Convert a 8 to a pinned one(memory won't moved by GC) if necessary.Z-DataZero a structure. There's no Storable or $ constraint on a, type, the length should be given in bytes.Z-DataCopy some bytes from a null terminated pointer(without copying the null terminator).You should consider using 5 type for storing NULL terminated bytes first, This method is provided if you really need to read , there's no encoding guarantee, result could be any bytes sequence.Z-DataCopy some bytes from a pointer.There's no encoding guarantee, result could be any bytes sequence.Z-DataCopy some bytes from a pointer.There's no encoding guarantee, result could be any bytes sequence.Z-Data Run FFI in bracket and marshall  std::string*4 result into Haskell heap bytes, memory pointed by  std::string* will be delete ed.Z-DataO(n), Convert from .Z-DataO(n), Convert tp .Z-Datain bytesZ-Datanumber of elementsZ-Datanumber of bytesZ-Data in elementsZ-Data in elementsZ-Datain bytesZ-Datain bytesZ-Data in elements   /$ /Base64 codec for bytes.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?IZ-Data!Exception during base64 decoding.Z-DataEncode  using base64 encoding.Z-DataReturn the encoded length of a given input length, always a multipler of 4.Z-Data version of .Z-DataText version of .Z-DataDecode a base64 encoding string, return Nothing on illegal bytes or incomplete input.Z-Data'Decode a base64 encoding string, throw  on error.Z-DataReturn the upper bound of decoded length of a given input length , return -1 if illegal(not a multipler of 4).  Textual numeric builders.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?0Z-Data0Control the rendering of floating point numbers.Z-DataScientific notation (e.g. 2.3e123).Z-DataStandard decimal notation.Z-Data(Use decimal notation for values between 0.1 and  9,999,999$, and scientific notation otherwise.Z-DataIntegral formatting options.Z-Data0total width, only effective with padding optionsZ-Datapadding optionsZ-Datashow + when the number is positiveZ-Data *defaultIFormat = IFormat 0 NoPadding FalseZ-Data int = intWith defaultIFormatZ-Data Format a   type like Int or Word16 into decimal ASCII digits. import Z.Data.Builder as B > B.buildText $ B.intWith defaultIFormat (12345 :: Int) "12345" > B.buildText $ B.intWith defaultIFormat{width=10, padding=RightSpacePadding} (12345 :: Int) "12345 " > B.buildText $ B.intWith defaultIFormat{width=10, padding=ZeroPadding} (12345 :: Int) "0000012345" Z-DataInternal formatting backed by C FFI, it must be used with type smaller than .We use rewrite rules to rewrite most of the integral types formatting to this function.Z-DataInternal formatting in haskell, it can be used with any bounded integral type.Other than provide fallback for the c version, this function is also used to check the c version's formatting result.Z-Data Format a  into decimal ASCII digits.Z-Data-Count how many decimal digits an integer has.Z-DataDecimal digit to ASCII digit.Z-Data Hexadecimal digit to ASCII char.Z-Data+Hexadecimal digit to UPPERCASED ASCII char.Z-Data Format a   type into hex nibbles. import Z.Data.Builder as B import Z.Data.Text as T import Data.Word import Data.Int > T.validate . B.build $ B.hex (125 :: Int8) "7d" > T.validate . B.build $ B.hex (-1 :: Int8) "ff" > T.validate . B.build $ B.hex (125 :: Word16) "007d" Z-DataThe UPPERCASED version of .Z-DataDecimal encoding of an IEEE .Using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise. Z-DataDecimal encoding of an IEEE .Using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise. Z-DataFormat single-precision float using drisu3 with dragon4 fallback. Z-DataFormat double-precision float using drisu3 with dragon4 fallback. Z-DataDecimal encoding of a ;, note grisu only handles strictly positive finite numbers. Z-DataDecimal encoding of a ?, note grisu3_sp only handles strictly positive finite numbers. Z-DataA Builder which renders a scientific number to full precision, using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999%, and scientific notation otherwise. Z-DataThis builder try to avoid scientific notation when 0 <= exponent < 16. Z-DataLike   but provides rendering options. Z-Data#Number of decimal places to render. Z-Data#Number of decimal places to render. Z-Data#Number of decimal places to render.# #  Builders for types from time.=(c) 2015-2016 Bryan O'Sullivan (c) 2020 Dong HanBSD3Dong  experimentalportableNone,  #$&-./289:<>?? Z-Data YYYY-mm-dd. Z-DataHH-MM-SS. Z-DataTimezone format in +HH:MM, with single letter Z for +00:00. Z-DataWrite  in ISO8061 YYYY-MM-DDTHH:MM:SS.SSSZ(time zone will always be Z). Z-DataWrite  in ISO8061 YYYY-MM-DDTHH:MM:SS.SSS. Z-DataWrite  in ISO8061 YYYY-MM-DD HH:MM:SS.SSSZ.  6Efficient serialization/format.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?"    UTF8 compatible builders.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-DataA class similar to <, serving the purpose that quickly convert a data type to a  value.You can use newtype or generic deriving to implement instance of this class quickly:  {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DerivingStrategies #-} import GHC.Generics newtype FooInt = FooInt Int deriving (Generic) deriving anyclass Print > toText (FooInt 3) > "FooInt 3" newtype FooInt = FooInt Int deriving (Generic) deriving newtype Print > toText (FooInt 3) > "3" Z-DataConvert data to  with precendence.You should return a $ writing in UTF8 encoding only, i.e. Z.Data.Text.validateMaybe (Z.Data.Builder.build (toUTF8BuilderP p a)) /= Nothing Z-DataConvert data to . Z-DataConvert data to  in UTF8 encoding. Z-DataConvert data to . Z-DataConvert data to  , faster  replacement. Z-DataEscape text using JSON string escaping rules and add double quotes, escaping rules:  '\b': "\b" '\f': "\f" '\n': "\n" '\r': "\r" '\t': "\t" '"': "\"" '\': "\\" other chars <= 0x1F: "\u00XX" Z-Data.Constructor without payload, convert to String Z-Data  HH:MM:SS.SSS Z-Data YYYY-MM-DDTHH:MM:SS.SSSZ Z-Data  YYYY-MM-DD Z-Data YYYY-MM-DDTHH:MM:SS.SSSZ Z-Data YYYY-MM-DDTHH:MM:SS.SSSZ Z-Data The escaping rules is same with  instance: we reuse JSON escaping rules here, so it will be faster. Z-DataConstructor with payloads2 2   Fast set based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-DataMapping values of within a set, the result size may change if there're duplicated values after mapping. Z-DataO(1) empty flat set. Z-Data O(N*logN)5 Pack list of values, on duplication prefer left one. Z-Data O(N*logN) Pack list of values with suggested size, on duplication prefer left one. Z-Data O(N*logN)6 Pack list of values, on duplication prefer right one. Z-Data O(N*logN) Pack list of values with suggested size, on duplication prefer right one. Z-DataO(N)7 Unpack a set of values to a list s in ascending order.This function works with  foldr/build fusion in base. Z-DataO(N)8 Unpack a set of values to a list s in descending order.This function works with  foldr/build fusion in base. Z-Data O(N*logN)7 Pack vector of values, on duplication prefer left one. Z-Data O(N*logN)8 Pack vector of values, on duplication prefer right one. Z-DataO(logN) Binary search on flat set. Z-DataO(N) Insert new value into set. Z-DataO(N) Delete a value from set. Z-DataO(n+m) Merge two  *, prefer right value on value duplication. Z-Data=Find the value's index in the vector, if value exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.  Fast map based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?O Z-DataO(1) empty flat map. Z-Data O(N*logN)= Pack list of key values, on key duplication prefer left one. Z-Data O(N*logN) Pack list of key values with suggested size, on key duplication prefer left one. Z-Data O(N*logN)> Pack list of key values, on key duplication prefer right one. Z-Data O(N*logN) Pack list of key values with suggested size, on key duplication prefer right one. Z-DataO(N) Unpack key value pairs to a list sorted by keys in ascending order.This function works with  foldr/build fusion in base. Z-DataO(N) Unpack key value pairs to a list sorted by keys in descending order.This function works with  foldr/build fusion in base. Z-Data O(N*logN)? Pack vector of key values, on key duplication prefer left one. Z-Data O(N*logN) Pack vector of key values, on key duplication prefer right one. Z-DataO(logN) Binary search on flat map. Z-DataO(N)> Insert new key value into map, replace old one if key exists. Z-DataO(N) Delete a key value pair by key. Z-DataO(N) Modify a value by key.7The value is evaluated to WHNF before writing into map. Z-DataO(n+m) Merge two  (, prefer right value on key duplication. Z-DataO(n+m) Merge two   with a merge function. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).(During folding k is in descending order. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).'During folding k is in ascending order. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).(During folding k is in descending order. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).'During folding k is in ascending order. Z-DataO(n).  f s ==   <$>  ((k, v) -> (,) k <$> f k v) (  m)* That is, behaves exactly like a regular  except that the traversing function also has access to the key associated with a value. Z-Data?Find the key's index in the vector slice, if key exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.  #Fast int set based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-DataMapping values of within a set, the result size may change if there're duplicated values after mapping. Z-DataO(1) empty flat set. Z-Data O(N*logN)5 Pack list of values, on duplication prefer left one. Z-Data O(N*logN) Pack list of values with suggested size, on duplication prefer left one. Z-Data O(N*logN)6 Pack list of values, on duplication prefer right one. Z-Data O(N*logN) Pack list of values with suggested size, on duplication prefer right one. Z-DataO(N)7 Unpack a set of values to a list s in ascending order.This function works with  foldr/build fusion in base. Z-DataO(N)8 Unpack a set of values to a list s in descending order.This function works with  foldr/build fusion in base. Z-Data O(N*logN)7 Pack vector of values, on duplication prefer left one. Z-Data O(N*logN)8 Pack vector of values, on duplication prefer right one. Z-DataO(logN) Binary search on flat set. Z-DataO(N) Insert new value into set. Z-DataO(N) Delete a value. Z-DataO(n+m) Merge two  *, prefer right value on value duplication. Z-DataFind the value's index in the vector slice, if value exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.  !#Fast int map based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-DataO(1) empty flat map. Z-Data O(N*logN)= Pack list of key values, on key duplication prefer left one. Z-Data O(N*logN) Pack list of key values with suggested size, on key duplication prefer left one. Z-Data O(N*logN)> Pack list of key values, on key duplication prefer right one. Z-Data O(N*logN) Pack list of key values with suggested size, on key duplication prefer right one. Z-DataO(N) Unpack key value pairs to a list sorted by keys in ascending order.This function works with  foldr/build fusion in base. Z-DataO(N) Unpack key value pairs to a list sorted by keys in descending order.This function works with  foldr/build fusion in base. Z-Data O(N*logN)? Pack vector of key values, on key duplication prefer left one. Z-Data O(N*logN) Pack vector of key values, on key duplication prefer right one. Z-DataO(logN) Binary search on flat map. Z-DataO(N)> Insert new key value into map, replace old one if key exists. Z-DataO(N) Delete a key value pair by key. Z-DataO(N) Modify a value by key.7The value is evaluated to WHNF before writing into map. Z-DataO(n+m) Merge two  (, prefer right value on key duplication. Z-DataO(n+m) Merge two   with a merge function. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).(During folding k is in descending order. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).)During folding Int is in ascending order. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).*During folding Int is in descending order. Z-DataO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).)During folding Int is in ascending order. Z-DataO(n).  f s ==   <$>  ((k, v) -> (,) k <$> f k v) (  m)* That is, behaves exactly like a regular  except that the traversing function also has access to the key associated with a value. Z-Data?Find the key's index in the vector slice, if key exists return  , otherwise , i.e. the insert index5This function only works on ascending sorted vectors.  2Unicode text processing(c) Dong Han, 2017-2020BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?  " Efficient deserialization/parse.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?\1 Z-DataType alias for a streaming parser, draw chunk from Monad m with a initial chunk, return result in  Either err x. Z-DataSimple CPSed parserA parser takes a failure continuation, and a success one, while the success continuation is usually composed by  instance, the failure one is more like a reader part, which can be modified via  . If you build parsers from ground, a pattern like this can be used:  xxParser = do ensureN errMsg ... -- make sure we have some bytes Parser $ kf k s inp -> -- fail continuation, success continuation, state token and input ... ... kf errMsg (if input not OK) ... k s ... (if we get something useful for next parser) Z-DataType alias for error message Z-DataA parse step consumes  and produce  . Z-Data3Simple parsing result, that represent respectively:9Success: the remaining unparsed data and the parsed value:Failure: the remaining unparsed data and the error messagePartial: that need for more input data, supply empty bytes to indicate  Z-DataUnsafely lifted an  action into  .This is only for debugging purpose(logging, etc). Don't mix compuation from realworld to parsing result, otherwise parsing is not deterministic. Z-Data version of . Z-Data Similar to :`, but can produce error message with current input chunk. Z-Data-Parse the complete input, without resupplying Z-DataParse the complete input, without resupplying, return the rest bytes Z-DataParse an input chunk Z-Data:Finish parsing and fetch result, feed empty bytes if it's   result. Z-DataRun a chunk parser with an initial input string, and a monadic action that can supply more input if needed. Z-DataRun a parser and keep track of all the input chunks it consumes. Once it's finished, return the final result (always   or  ) and all consumed chunks. Z-DataReturn both the result of a parse and the portion of the input that was consumed while it was being parsed. Z-DataEnsure that there are at least n< bytes available. If not, the computation will escape with  .Since this parser is used in many other parsers, an extra error param is provide to attach custom error info. Z-Data7Get current input chunk, draw new chunk if neccessary.  means EOF.Note this is different from  ,  1 only return what's left in current input chunk. Z-DataTest whether all input has been consumed, i.e. there are no remaining undecoded bytes. Fail if not  . Z-DataTest whether all input has been consumed, i.e. there are no remaining undecoded bytes. Z-Data+Decode a primitive type in host byte order. Z-Data)Decode a primitive type in little endian. Z-Data&Decode a primitive type in big endian. Z-DataA stateful scanner. The predicate consumes and transforms a state argument, and each transformed state is passed to successive invocations of the predicate on each byte of the input until one returns  or the input ends.This parser does not fail. It will return an empty string if the predicate returns  on the first byte of input. Z-Data Similar to  , but working on # chunks, The predicate consumes a  chunk and transforms a state argument, and each transformed state is passed to successive invocations of the predicate on each chunk of the input until one chunk got splited to Right (V.Bytes, V.Bytes) or the input ends. Z-Data.Match any byte, to perform lookahead. Returns ? if end of input has been reached. Does not consume any input. Z-DataMatch any byte, to perform lookahead. Does not consume any input, but will fail if end of input has been reached. Z-Data The parser  satisfy p0 succeeds for any byte for which the predicate p returns ,. Returns the byte that is actually parsed. digit = satisfy isDigit where isDigit w = w >= 48 && w <= 57 Z-Data The parser satisfyWith f p3 transforms a byte, and succeeds if the predicate p returns  on the transformed value. The parser returns the transformed byte that was parsed. Z-DataMatch a specific byte. Z-Data#Return a byte, this is an alias to  decodePrim Word8@. Z-DataMatch a specific 8bit char. Z-DataMatch a specific 7bit char. Z-DataMatch a specific UTF8 char. Z-Data&Take a byte and return as a 8bit char. Z-Data7Take a byte and return as a 7bit char, fail if exceeds 0x7F. Z-Data&Decode next few bytes as an UTF8 char.8Don't use this method as UTF8 decoder, it's slower than . Z-Data#Match either a single newline byte '\n'3, or a carriage return followed by a newline byte "\r\n". Z-Data  N bytes. Z-Data Skip a byte. Z-Data5Skip past input for as long as the predicate returns . Z-DataSkip over white space using . Z-Data/Consume input as long as the predicate returns ; or reach the end of input, and return the consumed input. Z-Data/Consume input as long as the predicate returns ; or reach the end of input, and return the consumed input. Z-Data Similar to  , but requires the predicate to succeed on at least one byte of input: it will fail if the predicate never returns  or reach the end of input Z-Data2Take all the remaining input chunks and return as . Z-Data Similar to  , but requires the predicate to succeed on next N bytes of input, and take N bytes(no matter if N+1 byte satisfy predicate or not). Z-Databytes s3 parses a sequence of bytes that identically match s. Z-DataSame as   but ignoring ASCII case. Z-Datatext s8 parses a sequence of UTF8 bytes that identically match s.> >   0#Textual numeric parsers.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-DataParse and decode an unsigned hex number, fail if input length is larger than (bit_size/4). The hex digits 'a' through 'f' may be upper or lower case.&This parser does not accept a leading "0x" string, and consider sign bit part of the binary hex nibbles, e.g.%parse' hex "FF" == Right (-1 :: Int8)&parse' hex "7F" == Right (127 :: Int8)'parse' hex "7Ft" == Right (127 :: Int8)parse' hex "7FF" == Left ["Z.Data.Parser.Numeric.hex","hex numeric number overflow"] Z-Data Same with  ., but only take as many as (bit_size/4) bytes.%parse' hex "FF" == Right (-1 :: Int8)&parse' hex "7F" == Right (127 :: Int8)'parse' hex "7Ft" == Right (127 :: Int8)'parse' hex "7FF" == Right (127 :: Int8) Z-Data Same with  (, but silently cast in case of overflow.%parse' hex "FF" == Right (-1 :: Int8)&parse' hex "7F" == Right (127 :: Int8)'parse' hex "7Ft" == Right (127 :: Int8)&parse' hex "7FF" == Right (-1 :: Int8) Z-Data+decode hex digits sequence within an array. Z-DataConvert A ASCII hex digit to  value. Z-Data Same with  (, but sliently cast in case of overflow. Z-Data,Parse and decode an unsigned decimal number.Will fail in case of overflow. Z-Data'Decode digits sequence within an array.9This function may overflow if result can't fit into type. Z-Data!Convert A ASCII decimal digit to  value. Z-Data'decode digits sequence within an array.A fast version to decode ( using machine word as much as possible. Z-Data*Take a single decimal digit and return as . Z-Data0Parse a decimal number with an optional leading '+' or '-' sign character.*This parser will fail if overflow happens. Z-Data Same with  (, but sliently cast if overflow happens. Z-Data"Parser specifically optimized for . Z-DataParse a rational number.6The syntax accepted by this parser is the same as for  .Note: this parser is not safe for use with inputs from untrusted sources. An input with a suitably large exponent such as "1e1000000000" will cause a huge  to be allocated, resulting in what is effectively a denial-of-service attack.#In most cases, it is better to use   or   instead. Z-Data%Parse a rational number and round to .This parser accepts an optional leading sign character, followed by at least one decimal digit. The syntax similar to that accepted by the . function, with the exception that a trailing '.' or 'e' not& followed by a number is not consumed.%Examples with behaviour identical to : parse' double "3" == ("", Right 3.0) parse' double "3.1" == ("", Right 3.1) parse' double "3e4" == ("", Right 30000.0) parse' double "3.1e4" == ("", Right 31000.0) parse' double ".3" == (".3", Left ParserError) parse' double "e3" == ("e3", Left ParserError)Examples of differences from : parse' double "3.foo" == (".foo", Right 3.0) parse' double "3e" == ("e", Right 3.0) parse' double "-3e" == ("e", Right -3.0)This function does not accept string representations of "NaN" or "Infinity". Z-Data%Parse a rational number and round to .Single precision version of  . Z-DataParse a scientific number.6The syntax accepted by this parser is the same as for  . Z-DataParse a scientific number and convert to result using a user supply function.6The syntax accepted by this parser is the same as for  . Z-DataParse a rational number.6The syntax accepted by this parser is the same as for  .Note: this parser is not safe for use with inputs from untrusted sources. An input with a suitably large exponent such as "1e1000000000" will cause a huge  to be allocated, resulting in what is effectively a denial-of-service attack.#In most cases, it is better to use   or   instead. Z-Data$More strict number parsing(rfc8259).  support parse 2314. and  21321exyz without eating extra dot or e via backtrack, this is not allowed in some strict grammer such as JSON, so we make an non-backtrack strict number parser separately using LL(1) lookahead. This parser also agree with  on extra dot or e handling: parse' double "3.foo" == Left ParseError parse' double "3e" == Left ParseErrorLeading zeros or + sign is also not allowed: parse' double "+3.14" == Left ParseError parse' double "0014" == Left ParseErrorIf you have a similar grammer, you can use this parser to save considerable time.  number = [ minus ] int [ frac ] [ exp ] decimal-point = %x2E ; . digit1-9 = %x31-39 ; 1-9 e = %x65 / %x45 ; e E exp = e [ minus / plus ] 1*DIGIT frac = decimal-point 1*DIGIT This function does not accept string representations of "NaN" or "Infinity". reference: -https://tools.ietf.org/html/rfc8259#section-6 Z-Data%Parse a rational number and round to  using stricter grammer.Single precision version of  . Z-DataParse a scientific number.6The syntax accepted by this parser is the same as for  . Z-DataParse a scientific number and convert to result using a user supply function.6The syntax accepted by this parser is the same as for  . Z-Data!accumulator, usually start from 0 Z-Data!accumulator, usually start from 0  $Parsers for types from time.=(c) 2015-2016 Bryan O'Sullivan (c) 2020 Dong HanBSD3Dong  experimentalportableNone,  #$&-./289:<>?n Z-DataParse a date of the form [+,-]YYYY-MM-DD. Z-DataParse a time of the form HH:MM[:SS[.SSS]]. Z-DataParse a time zone, and return  if the offset from UTC is zero. (This makes some speedups possible.) Z-Data#Parse a date and time, of the form YYYY-MM-DD HH:MM[:SS[.SSS]]$. The space may be replaced with a T. The number of seconds is optional and may be followed by a fractional component. Z-Data Behaves as  7, but converts any time zone offset into a -- UTC time. Z-Data5Parse a date with time zone info. Acceptable formats:  YYYY-MM-DD HH:MM Z YYYY-MM-DD HH:MM:SS Z YYYY-MM-DD HH:MM:SS.SSS Z !The first space may instead be a T*, and the second space is optional. The Z represents UTC. The Z6 may be replaced with a time zone offset of the form +0000 or -08:00-, where the first two digits are hours, the : is optional and the second two digits (also optional) are minutes.  7 Efficient deserialization/parse.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?R  %JSON representation and parsers(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?'= Z-Data,A JSON value represented as a Haskell value.The Object's payload is a key-value vector instead of a map, which parsed directly from JSON document. This design choice has following advantages:4Allow different strategies handling duplicated keys.Allow different Map" type to do further parsing, e.g. 488Roundtrip without touching the original key-value order.Save time if constructing map is not neccessary, e.g. using a linear scan to find a key if only that key is needed. Z-Data Lense for   element. return   if   is not an   or index not exist.Modify will have no effect if   is not an   or index not exist. Z-Data Lense for   element return   if   is not an   or key not exist.Modify will have no effect if   is not an   or key not exist.'On duplicated keys prefer the last one. Z-DataParse  " without consuming trailing bytes. Z-DataParse  , and consume all trailing JSON white spaces, if there're bytes left, parsing will fail. Z-DataThe only valid whitespace in a JSON document is space, newline, carriage pure, and tab. Z-DataJSON   parser. Z-Data*parse json array with leading SQUARE_LEFT. Z-Dataparse json array with leading 6. Z-Data*Convert IEEE float to scientific notition. Z-Data+Convert IEEE double to scientific notition.  & JSON representation and builders(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?0 Z-DataUse : as separator to connect a label(no escape, only add quotes) with field builders.,Don't use chars which need escaped in label. Z-DataUse : as separator to connect a label(escape the label and add quotes) with field builders. Z-Data Encode a  !, you can use this function with toValue to get  encodeJSON with a small overhead. Z-DataEscape text into JSON string and add double quotes, escaping rules:  '\b': "\b" '\f': "\f" '\n': "\n" '\r': "\r" '\t': "\t" '"': "\"" '\': "\\" 'DEL': "\u007f" other chars <= 0x1F: "\u00XX" Z-Data8'ValuePretty'' with 4 spaces indentation per level, e.g. { "results": [ { "from_user_id_str":"80430860", "profile_image_url":" ?http://a2.twimg.com/profile_images/536455139/icon32_normal.png", "created_at":"Wed, 26 Jan 2011 07:07:02 +0000", "from_user":"kazu_yamamoto", "id_str":"30159761706061824", "metadata": { "result_type":"recent" }, "to_user_id":null, "text":"Haskell Server Pages ```````````", "id":30159761706061824, "from_user_id":80430860, "geo":null, "iso_language_code":"no", "to_user_id_str":null, "source":"<a href="http:/ twitter.com">web</a>" } ], "max_id":30159761706061824, "since_id":0, "refresh_url":"?since_id=30159761706061824&q=haskell", "next_page":"?page=2&max_id=30159761706061824&rpp=1&q=haskell", "results_per_page":1, "page":1, "completed_in":1.2606e-2, "since_id_str":"0", "max_id_str":"30159761706061824", "query":"haskell" } Z-Data Encode a   with indentation and linefeed. Z-Dataindentation per levelZ-Datainitial indentation  ' IR Converter(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?5 Z-Data ; provides a monadic interface to convert protocol IR (e.g.Value) to Haskell ADT. Z-Data!Error info with (JSON) Path info. Z-DataElements of a (JSON) Value path used to describe the location of an error. Z-Data4Path element of a key into an object, "object.key". Z-Data8Path element of an index into an array, "array[index]". Z-Data path of a embedded (JSON) String Z-DataRun a   with input value. Z-Data version of . Z-Data&Add (JSON) Path context to a converterWhen converting a complex structure, it helps to annotate (sub)converters with context, so that if an error occurs, you can find its location. withFlatMapR "Person" $ \o -> Person <$> o .: "name" Key "name" <*> o .: "age" Key "age"(Standard methods like (.:) already do this.)With such annotations, if an error occurs, you will get a (JSON) Path location of that error. Z-DataAdd context to a failure message, indicating the name of the structure being converted. prependContext "MyType" (fail "[error message]") -- Error: "converting MyType failed, [error message]"   9 ('Fast JSON serialization/deserialization(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?P: Z-DataGeneric encode/decode SettingsThere should be no control characters in formatted texts since we don't escaping those field names or constructor names ( 2 relys on Haskell's lexical property). Otherwise  ! will output illegal JSON string. Z-Dataformat field labels Z-Dataformat constructor names Z-Datatake missing field as  ? Z-DataA newtype for <, whose semigroup's instance is to connect two builder with . Z-Data$Type class for encode & decode JSON. Z-Data=Decode a JSON doc, only trailing JSON whitespace are allowed. Z-Data-Decode a JSON text, return any trailing text. Z-Data=Decode a JSON doc, only trailing JSON whitespace are allowed. Z-Data/Decode a JSON bytes, return any trailing bytes. Z-DataDecode a JSON doc chunk. Z-Data.Decode JSON doc chunks, return trailing bytes. Z-Data#Directly encode data to JSON bytes.This function use   to balance common use case, if you need fine tuning on memory usage, please use & and a custom initial chunk size with  . Z-Data!Encode data to JSON bytes chunks. Z-Data Text version  . Z-DataRun a   with input value. Z-Data#Directly encode data to JSON bytes. Z-DataProduce an error message like 4converting XXX failed, expected XXX, encountered XXX. Z-Data  name f value applies f to the  number when value is a   and fails using   otherwise.Warning: If you are converting from a scientific to an unbounded type such as  you may want to add a restriction on the size of the exponent (see  ) to prevent malicious input from filling up the memory of the target system.Error message example withScientific "MyType" f (String "oops") -- Error: "converting MyType failed, expected Number, but encountered String" Z-Data@ 5 try to convert floating number with following rules:Use  Infinity# to represent out of range numbers.Convert Null as NaN Z-Data  name f value applies f to the  number when value is a  * with exponent less than or equal to 1024. Z-Data  name f value applies f to the  number when value is a   and value is within minBound ~ maxBound. Z-Data Directly use  & as key-values for further converting. Z-DataTake a   as an 'FM.FlatMap T.Text Value', on key duplication prefer first one. Z-DataTake a   as an 'FM.FlatMap T.Text Value', on key duplication prefer last one. Z-DataTake a   as an 'HM.HashMap T.Text Value', on key duplication prefer first one. Z-DataTake a   as an 'HM.HashMap T.Text Value', on key duplication prefer last one. Z-Data$Decode a nested JSON-encoded string. Z-Data7Retrieve the value associated with the given key of an  . The result is  if the key is not present or the value cannot be converted to the desired type.2This accessor is appropriate if the key and value must be present in an object for it to be valid. If the key and value are optional, use   instead. Z-Data7Retrieve the value associated with the given key of an  . The result is . if the key is not present or if its value is  , or fail if the value cannot be converted to the desired type.This accessor is most useful if the key and value can be absent from an object without affecting its validity. If the key and value are mandatory, use   instead. Z-Data7Retrieve the value associated with the given key of an  . The result is  if the key is not present or fail if the value cannot be converted to the desired type.This differs from   by attempting to convert   the same as any other JSON value, instead of interpreting it as . Z-Data Variant of  " with explicit converter function. Z-Data Variant of  " with explicit converter function. Z-DataUse ,* as separator to connect list of builders. Z-DataUse ,. as separator to connect a vector of builders. Z-DataConnect key and value to a   using , key will be escaped. Z-DataAdd curly for comma connected  s. Z-Data1Connect key and value to a tuple to be used with  . Z-Data Alias for  Object . pack. Z-Data Settings T.pack T.pack False Z-Data"Constructor with multiple payloads Z-Data!Constructor with a single payload Z-Data.Constructor without payload, convert to String Z-Data"Constructor with multiple payloads Z-Data!Constructor with a single payload Z-Data.Constructor without payload, convert to String Z-DataThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype Fixed and provide your own instance using  $ if you want to allow larger inputs. Z-DataThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype Ratio and provide your own instance using  $ if you want to allow larger inputs. Z-DataThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype % and provide your own instance using  $ if you want to allow larger inputs. Z-DataThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype % and provide your own instance using  $ if you want to allow larger inputs. Z-DataThis is an INCOHERENT instance, to provide JSON text encoding behaviour. Z-DataThis is an INCOHERENT instance, encode binary data with base64 encoding. Z-Data!default instance prefer later key Z-Data!default instance prefer later key Z-Data-Note this instance doesn't reject large input Z-Data"Constructor with multiple payloads Z-Data!Constructor with a single payload Z-Data.Constructor without payload, convert to String Z-Data/The name of the type you are trying to convert.Z-Data*The JSON value type you expecting to meet.Z-DataThe actual value encountered. Z-Datadata type nameZ-Data/a inner converter which will get the converted  . Z-Data4the field converter (value part of a key value pair)   8 8)'Fast JSON serialization/deserialization(c) Dong Han, 2020BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?W5 Z-DataSnake casing a pascal cased constructor name or camel cased field name, words are always lower cased and separated by an underscore. Z-DataTrain casing a pascal cased constructor name or camel cased field name, words are always lower cased and separated by a hyphen. Z-DataUse   as Proxy a Z-Data${"seconds": SSS, "nanoseconds": NNN}. Z-DataThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype & and provide your own instance using  $ if you want to allow larger inputs. Z-DataThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype & and provide your own instance using  $ if you want to allow larger inputs. Z-Data  HH:MM:SS.SSS Z-Data YYYY-MM-DDTHH:MM:SS.SSSZ Z-Data  YYYY-MM-DD Z-Data YYYY-MM-DDTHH:MM:SS.SSSZ Z-Data YYYY-MM-DDTHH:MM:SS.SSSZ Z-DataOnly round trip  as JSON array. *Hex codec for bytes.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?[3Z-DataException during hex decoding.Z-DataNew type wrapper for 2 with hex encoding(uppercase) Show/JSON instances.Z-DataEncode  using hex(base16) encoding.Z-Data version of .Z-DataText version of .Z-DataDecode a hex encoding string, return Nothing on illegal bytes or incomplete input.Z-Data$Decode a hex encoding string, throw  on error.Z-Data uppercase?Z-Data uppercase?Z-Data uppercase?Null-ternimated byte string.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?x%Z-DataA efficient wrapper for short immutable null-terminated byte sequences which can be automatically freed by ghc garbage collector.The main use case of this type is to ease the bridging of C FFI APIs, since most of the unix APIs use null-terminated string. On windows you're encouraged to use a compatibility layer like 'WideCharToMultiByte/MultiByteToWideChar' and keep the same interface, e.g. libuv do this when deal with file paths. don't support O(1) slicing, it's not suitable to use it to store large byte chunk, If you need advance editing, convert  to/from  with  pattern or  / , then use vector combinators.8When textual represatation is needed e.g. converting to , ,  instance, etc., we assume  using UTF-8 encodings,  can be used with OverloadedString6, literal encoding is UTF-8 with some modifications: \NUL is encoded to 'C0 80', and \xD800 ~ \xDFFF4 is encoded as a three bytes normal utf-8 codepoint.Note most of the unix API is not unicode awared though, you may find a scandir call return a filename which is not proper encoded in any unicode encoding at all. But still, UTF-8 is recommanded to be used when text represatation is needed.Z-Data Convert to a \NUL terminated ,;There's an invariance that this array never contains extra \NUL except terminator.Z-Data'Use this pattern to match or construct ', result will be trimmed down to first \NUL byte if there's any.Z-Data Construct a < from arbitrary array, result will be trimmed down to first \NUL byte if there's any.Z-Data Construct a  from a .!Result will be shrinked to first \NUL$ byte without copy. If there is no \NUL found in the array, We will resize the origin MutablePrimArray, so, to avoid undefined behaviour, the original MutablePrimArray shall not be accessed anymore. Moreover, no reference to the old one should be kept in order to allow garbage collection of the original MutablePrimArray in case a new MutablePrimArray had to be allocated.Z-DataPoke  until a \NUL terminator(or to the end of the array if there's none).Z-DataPoke  with \NUL terminator.Z-DataConcatenate two .Z-DataEmpty Z-Data Singleton .Z-DataO(n) Concatenate a list of .Z-DataO(n) The  function takes a  and a list of  s and concatenates the list after interspersing the first argument between each element of the list.Note:  will force the entire  list.Z-DataO(n) An efficient way to join CByte s with a byte.Intercalate bytes list with \NUL4 will effectively leave the first bytes in the list.Z-DataPack a  into .\NUL is encoded as two bytes C0 80 , \xD800 ~ \xDFFF4 is encoded as a three bytes normal UTF-8 codepoint.Z-DataO(n)> Convert cbytes to a char list using UTF8 encoding assumption.$This function is much tolerant than +, it simply decoding codepoints using UTF8 < without checking errors such as overlong or invalid range.Unpacking is done lazily. i.e. we will retain reference to the array until all element are consumed.This function is a  good producer$ in the sense of build/foldr fusion.Z-DataReturn  if  is empty.Z-DataO(1), Return the BTYE length of  without NULL terminator.Z-DataO(1) , convert to /, which can be processed by vector combinators.Z-DataO(1) , convert to  with its NULL terminator.Z-DataO(n), convert from %Result will be trimmed down to first \NUL byte if there's any.Z-DataO(n) , convert to  using UTF8 encoding assumption.Throw  in case of invalid codepoint.Z-DataO(n) , convert to  using UTF8 encoding assumption.Return  in case of invalid codepoint.Z-DataO(n), convert from ,%Result will be trimmed down to first \NUL byte if there's any.Z-DataWrite  's byte sequence to buffer. This function is different from   instance in that it directly write byte sequence without checking if it's UTF8 encoded.Z-DataWrite 6 's byte sequence to buffer, with its NULL terminator.Z-DataBuild a ; with builder, will automatically be trimmed down to first \NUL: byte if there's any, or append with one if there's none.Z-DataCopy a  type into a  , return  if the pointer is NULL.&After copying you're free to free the  's memory.Z-Data Same with  , but only take at most N bytes.%Result will be trimmed down to first \NUL byte if there's any.Z-DataPass  to foreign function as a  const char*.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-DataPass  list to foreign function as a  StgArrBytes**.Enable UnliftedFFITypes% extension in your haskell code, use  StgArrBytes** (>=8.10) or StgMutArrPtrs*(<8.10) pointer type and HsInt to marshall BAArray# and Int- arguments on C side, check the example with .,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-DataPass  to foreign function as a  const char*.0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-DataPass  list to foreign function as a  const char**.Check  Z.Foreign< module for more detail on how to marshall params in C side.Z-Data Create a  with IO action.5If (<=0) capacity is provided, a pointer pointing to \NUL' is passed to initialize function and 3 will be returned. This behavior is different from 2, which may cause trouble for some FFI functions.,USE THIS FUNCTION WITH UNSAFE FFI CALL ONLY.Z-Data Create a  with IO action.!If (<=0) capacity is provided, a  ' is passed to initialize function and = will be returned. Other than that, User have to make sure a \NUL$ ternimated string will be written.Z-Data Run FFI in bracket and marshall  std::string* result into , memory pointed by  std::string* will be delete ed.Z-DataJSON instances check if : is properly UTF8 encoded, if it is, decode/encode it as -, otherwise as an object with a base64 field. > encodeText ("hello" :: CBytes) ""hello"" > encodeText ("hello\NUL" :: CBytes) -- \NUL is encoded as C0 80, which is illegal UTF8 "{"base64":"aGVsbG/AgA=="}" Z-DataThis instance provide UTF8 guarantee, illegal codepoints will be written as s.Escaping rule is same with .Z-Datacapacity n(including the \NUL terminator)Z-Datainitialization function,Z-Datacapacity n(including the \NUL terminator)Z-Datainitialization function,%&Lightweight foreign pointer(c) Dong Han, 2020BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?}YZ-DataLightweight foreign pointers.Z-Data Initialize a 4 with initializer which return an allocated pointer.Z-Data Initialize a 4 with initializer(must be unsafe FFI) and finalizer.The initializer will receive a pointer of pointer so that it can do allocation and write pointer back.Z-Data Initialize a  with initializer and finalizer.The initializer will receive a pointer of pointer so that it can do allocation and write pointer back.Z-DataThe only way to use  as a  in FFI is to use .Z-DataPass a list of 'CPtr Foo' as foo**). USE THIS FUNCTION WITH UNSAFE FFI ONLY!Z-DataPass a list of 'CPtr Foo' as foo**.Z-Data initializerZ-Data finalizerZ-Data initializerZ-Data finalizerZ-Data initializerZ-Data finalizer    + RE2 regex(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-Data"Exception thrown when using regex.Z-DataRE2 Regex options.The options are ( in parentheses):  posix_syntax (false) restrict regexps to POSIX egrep syntax longest_match (false) search for longest match, not first match log_errors (true) log syntax and execution errors to ERROR max_mem (8<<20) approx. max memory footprint of RE2 literal (false) interpret string as literal, not regexp never_nl (false) never match \n, even if it is in regexp dot_nl (false) dot matches everything including new line never_capture (false) parse all parens as non-capturing case_sensitive (true) match is case-sensitive (regexp can override with (?i) unless in posix_syntax mode) The following options are only consulted when posix_syntax == true. When posix_syntax == false, these features are always enabled and cannot be turned off; to perform multi-line matching in that case, begin the regexp with (?m).  perl_classes (false) allow Perl's \d \s \w \D \S \W word_boundary (false) allow Perl's \b \B (word boundary and not) one_line (false) ^ and $ only match beginning and end of text Z-DataA compiled RE2 regex.Z-Data!capturing group number(including \0)Z-DataGet back regex's pattern.Z-DataDefault regex options, see .Z-DataCompile a regex pattern, throw  in case of illegal patterns.Z-Data+Compile a regex pattern withOptions, throw  in case of illegal patterns.Z-DataEscape a piece of text literal so that it can be safely used in regex pattern.escape "(\\d+)""\\(\\\\d\\+\\)"Z-Data$Check if text matched regex pattern.Z-DataCheck if text matched regex pattern, if so return matched part, all capturing groups(from \1") and the text after matched part.Nothing. indicate a non-matching capturing group, e.g.*match (regex "(foo)|(bar)baz") "barbazbla"&("barbaz",[Nothing,Just "bar"], "bla")Z-DataReplace matched part in input with a rewrite pattern. If no matched part found, return the original input.=replace (regex "red") False "A red fox with red fur" "yellow""A yellow fox with red fur"=replace (regex "red") True "A red fox with red fur" "yellow""A yellow fox with yellow fur"Z-DataExtract capturing group to an extract pattern. If no matched capturing group found, return an empty string.extract (regex "(\\d{4})-(\\d{2})-(\\d{2})") "Today is 2020-12-15" "month: \\2, date: \\3""month: 12, date: 15"Z-Dataglobally replace?Z-DatainputZ-DatarewriteZ-DatainputZ-Dataextract9:;<=><=?<@A<  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  <  < < < < < < < < < < < < < KLKLKLKLKLKLKLKLKLKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKNKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK<<<9 9 < <<<< 9 <9 << <<%Z-Data-0.8.3.0-37u7OlWXbeeLJtWSrSJkMP Z.Data.ArrayZ.Foreign.CPtr Z.Data.CBytesZ.Data.Vector.Sort Z.Foreign Z.Data.ASCIIZ.Data.Array.CastZ.Data.Array.UnalignedZ.Data.Array.UnliftedArrayZ.Data.Array.QQZ.Data.Array.Checked!Z.Data.Builder.Numeric.DigitTableZ.Data.Generics.UtilsZ.Data.PrimRef.PrimSTRefZ.Data.PrimRef.PrimIORefZ.Data.Text.UTF8CodecZ.Data.Text.UTF8RewindZ.Data.Vector.BaseZ.Data.Vector.QQZ.Data.Vector.SearchZ.Data.Vector.ExtraZ.Data.Text.BaseZ.Data.Text.SearchZ.Data.Text.ExtraZ.Data.Builder.BaseZ.Data.Vector.Base64Z.Data.Builder.NumericZ.Data.Builder.TimeZ.Data.Text.PrintZ.Data.Vector.FlatSetZ.Data.Vector.FlatMapZ.Data.Vector.FlatIntSetZ.Data.Vector.FlatIntMapZ.Data.Parser.BaseZ.Data.Parser.NumericZ.Data.Parser.TimeZ.Data.JSON.ValueZ.Data.JSON.BuilderZ.Data.JSON.ConverterZ.Data.JSON.Base Z.Data.JSONZ.Data.Vector.HexZ.Data.Text.Regex Data.Array uninitializedZ.Data.PrimRef isCategoryPreludeunlines Z.Data.TextShowT Z.Data.VectorCBytesZ.Data.Builder Z.Data.ParserFlatMapghc-primGHC.Prim RealWorldbaseGHC.PtrPtrFunPtrForeign.C.StringCStringGHC.IO.ExceptionUndefinedElementIndexOutOfBoundsArrayExceptionData.OrdgetDownDowncastPtrnullPtr'primitive-0.7.1.0-Jxsyd70oUttYiCXCa0HqVData.Primitive.PtrcopyPtrToMutablePrimArrayData.Primitive.PrimArraymutablePrimArrayContentsprimArrayContentsnewAlignedPinnedPrimArraynewPinnedPrimArrayisMutablePrimArrayPinnedisPrimArrayPinnedcopyMutablePrimArrayToPtrcopyPrimArrayToPtr PrimArrayMutablePrimArrayData.Primitive.TypessizeOf setOffAddr# writeOffAddr# readOffAddr# indexOffAddr# setByteArray#writeByteArray#readByteArray#indexByteArray# alignment#sizeOf#PrimData.Primitive.SmallArray SmallArraySmallMutableArrayData.Primitive.Arrayarray#Arraymarray# MutableArrayControl.Monad.PrimitivetouchDELTILDE CURLY_RIGHT BRACE_RIGHTORBAR CURLY_LEFT BRACE_LEFTLETTER_zLETTER_yLETTER_xLETTER_wLETTER_vLETTER_uLETTER_tLETTER_sLETTER_rLETTER_qLETTER_pLETTER_oLETTER_nLETTER_mLETTER_lLETTER_kLETTER_jLETTER_iLETTER_hLETTER_gLETTER_fLETTER_eLETTER_dLETTER_cLETTER_bLETTER_aGRAVE UNDERSCORECIRCUM SQUARE_RIGHT BRACKET_RIGHT BACKSLASH SQUARE_LEFT BRACKET_LEFTLETTER_ZLETTER_YLETTER_XLETTER_WLETTER_VLETTER_ULETTER_TLETTER_SLETTER_RLETTER_QLETTER_PLETTER_OLETTER_NLETTER_MLETTER_LLETTER_KLETTER_JLETTER_ILETTER_HLETTER_GLETTER_FLETTER_ELETTER_DLETTER_CLETTER_BLETTER_AATQUESTION ANGLE_RIGHTGREATEREQUAL ANGLE_LEFTLESS SEMICOLONCOLONDIGIT_9DIGIT_8DIGIT_7DIGIT_6DIGIT_5DIGIT_4DIGIT_3DIGIT_2DIGIT_1DIGIT_0SLASHDOTPERIODMINUSHYPHENCOMMAPLUSASTERISK PAREN_RIGHT PAREN_LEFT SINGLE_QUOTEAND AMPERSANDPERCENTDOLLAR NUMBER_SIGNHASH DOUBLE_QUOTEEXCLAMSPACEUSRSGSFSESCSUBEMCANETBSYNNAKDC4DC3DC2DC1DLESISOCARRIAGE_RETURN FORM_FEED VERTICAL_TABNEWLINETABBSBELACKENQEOTETXSTXSOHNULw2cc2wisASCIIisUpperisLowertoLowertoUpper toLowerLatin toUpperLatin isControlisSpaceisDigit isOctDigit isHexDigitCastcast$fCastFloatInt32$fCastDoubleInt64$fCastInt32Float$fCastInt64Double$fCastFloatWord32$fCastDoubleWord64$fCastWord32Float$fCastWord64Double $fCastWordInt$fCastWord64Int64$fCastWord32Int32$fCastWord16Int16$fCastWord8Int8 $fCastIntWord$fCastInt64Word64$fCastInt32Word32$fCastInt16Word16$fCastInt8Word8$fCastabBEgetBELEgetLE Unaligned unalignedSizeindexWord8ArrayAs#readWord8ArrayAs#writeWord8ArrayAs#peekMBApokeMBAindexBA UnalignedSizegetUnalignedSizewriteWord8ArrayAsreadWord8ArrayAsindexWord8ArrayAswritePrimWord8ArrayAsreadPrimWord8ArrayAsindexPrimWord8ArrayAs primArrayToBEprimArrayFromBE$fUnaligned(,,,,,,,)$fUnaligned(,,,,,,)$fUnaligned(,,,,,)$fUnaligned(,,,,)$fUnaligned(,,,)$fUnaligned(,,)$fUnaligned(,)$fUnalignedChar$fUnalignedDouble$fUnalignedFloat$fUnalignedPtr$fUnalignedInt$fUnalignedInt64$fUnalignedInt32$fUnalignedInt16$fUnalignedWord$fUnalignedWord64$fUnalignedWord32$fUnalignedWord16$fUnalignedInt8$fUnalignedWord8 $fUnalignedLE$fUnalignedLE0$fUnalignedLE1$fUnalignedLE2$fUnalignedLE3$fUnalignedLE4$fUnalignedLE5$fUnalignedLE6$fUnalignedLE7$fUnalignedLE8$fUnalignedLE9 $fUnalignedBE$fUnalignedBE0$fUnalignedBE1$fUnalignedBE2$fUnalignedBE3$fUnalignedBE4$fUnalignedBE5$fUnalignedBE6$fUnalignedBE7$fUnalignedBE8$fUnalignedBE9$fShowBE$fEqBE$fShowLE$fEqLE$fShowUnalignedSize$fEqUnalignedSize$fOrdUnalignedSize$fNumUnalignedSize$fUnalignedCDouble$fUnalignedCFloat$fUnalignedCSUSeconds$fUnalignedCUSeconds$fUnalignedCTime$fUnalignedCClock$fUnalignedCUIntMax$fUnalignedCIntMax$fUnalignedCUIntPtr$fUnalignedCIntPtr$fUnalignedCBool$fUnalignedCULLong$fUnalignedCLLong$fUnalignedCSigAtomic$fUnalignedCWchar$fUnalignedCSize$fUnalignedCPtrdiff$fUnalignedCULong$fUnalignedCLong$fUnalignedCUInt$fUnalignedCInt$fUnalignedCUShort$fUnalignedCShort$fUnalignedCUChar$fUnalignedCSChar$fUnalignedCChar UnliftedArrayMutableUnliftedArray PrimUnliftedwriteUnliftedArray#readUnliftedArray#indexUnliftedArray#unsafeNewUnliftedArraynewUnliftedArraysetUnliftedArraysizeofUnliftedArraysizeofMutableUnliftedArraywriteUnliftedArrayreadUnliftedArrayindexUnliftedArrayunsafeFreezeUnliftedArraysameMutableUnliftedArraycopyUnliftedArraycopyMutableUnliftedArrayfreezeUnliftedArraythawUnliftedArraycloneUnliftedArraycloneMutableUnliftedArray$fPrimUnliftedIORef$fPrimUnliftedSTRef$fPrimUnliftedTVar$fPrimUnliftedMVar$fPrimUnliftedMutablePrimArray$fPrimUnliftedMutableByteArray$fPrimUnliftedByteArray$fPrimUnliftedPrimArrayArrMArrnewArr newArrWithreadArrwriteArrsetArrindexArr indexArr' indexArrM freezeArrthawArrunsafeFreezeArr unsafeThawArrcopyArrcopyMutableArrmoveArrcloneArrcloneMutableArrresizeMutableArrshrinkMutableArrsameMutableArr sizeofArrsizeofMutableArrsameArrwithPrimArrayContentswithMutablePrimArrayContents castArraycastMutableArrayemptyArr singletonArr doubletonArrmodifyIndexArrinsertIndexArrdeleteIndexArr$fArrUnliftedArraya$fArrPrimArraya$fArrSmallArraya $fArrArraya asciiLiteralarrASCIIword8ArrayFromAddrint8ArrayFromAddr utf8Literal arrayLiteral word8LiteralarrW8 int8LiteralarrI8 word16LiteralarrW16word16ArrayFromAddrint16ArrayFromAddr int16LiteralarrI16 word32LiteralarrW32word32ArrayFromAddrint32ArrayFromAddr int32LiteralarrI32 word64LiteralarrW64word64ArrayFromAddrint64ArrayFromAddr int64LiteralarrI64wordArrayFromAddrintArrayFromAddr wordLiteral intLiteralarrWordarrInt decDigitTable hexDigitTablehexDigitTableUpperSumSizeSSize ProductSizePSize productSizesumSize$fProductSize:*:$fProductSizeM1 $fSumSize:+: $fSumSizeM1 PrimSTRef newPrimSTRef readPrimSTRefwritePrimSTRefmodifyPrimSTRefCounter PrimIORef newPrimIORef readPrimIORefwritePrimIORefmodifyPrimIORef newCounteratomicAddCounter'atomicAddCounteratomicAddCounter_atomicSubCounter'atomicSubCounteratomicSubCounter_atomicAndCounter'atomicAndCounteratomicAndCounter_atomicNandCounter'atomicNandCounteratomicNandCounter_atomicOrCounter'atomicOrCounteratomicOrCounter_atomicXorCounter'atomicXorCounteratomicXorCounter_encodeCharLength encodeChar encodeChar#encodeCharModifiedUTF8encodeCharModifiedUTF8# decodeChar decodeChar_ decodeChar# decodeCharLendecodeCharLen#decodeCharReversedecodeCharReverse_decodeCharReverse#decodeCharLenReversedecodeCharLenReverse#between#isContinueByte#chr1#chr2#chr3#chr4#copyChar copyChar'replacementCharCategoryNormalizationResult NormalizedYesNormalizedMaybe NormalizedNo NormalizeModeNFCNFKCNFDNFKDLocale envLocaleCategoryIsxdigitCategoryIsdigitCategoryIslowerCategoryIsupperCategoryIsalphaCategoryIsalnumCategoryIspunctCategoryIsgraphCategoryIsblankCategoryIsspaceCategoryIsprintCategoryIscntrlCategoryIgnoreGraphemeClusterCategoryCompatibilityCategoryUnassignedCategoryPrivateUseCategorySurrogateCategoryFormatCategoryControlCategorySeparatorCategorySeparatorParagraphCategorySeparatorLineCategorySeparatorSpaceCategorySymbolCategorySymbolOtherCategorySymbolModifierCategorySymbolCurrencyCategorySymbolMathCategoryPunctuationCategoryPunctuationOtherCategoryPunctuationFinalCategoryPunctuationInitialCategoryPunctuationCloseCategoryPunctuationOpenCategoryPunctuationDashCategoryPunctuationConnectorCategoryNumberCategoryNumberOtherCategoryNumberLetterCategoryNumberDecimal CategoryMarkCategoryMarkEnclosingCategoryMarkSpacingCategoryMarkNonSpacingCategoryCaseMappedCategoryLetterCategoryLetterOtherCategoryLetterTitlecaseCategoryLetterLowercaseCategoryLetterUppercaseLocaleTurkishAndAzeriLatinLocaleLithuanian LocaleDefaultnormalizeModeToFlagtoNormalizationResult$fShowNormalizationResult$fEqNormalizationResult$fOrdNormalizationResult$fGenericNormalizationResult$fShowNormalizeMode$fEqNormalizeMode$fOrdNormalizeMode$fGenericNormalizeModeVectorExceptionIndexOutOfVectorRange EmptyVectorIPairifstisndBytes PrimVectorVectorVecIArraytoArrfromArr c_memrchrc_memchr c_fnv_hash_bac_fnv_hash_addrc_ascii_validate_addrc_strlenc_strcmparrVec indexMaybe traverseVectraverseWithIndex traverseVec_traverseWithIndex_ packASCIIcreatecreate'creating creating'createNcreateN2empty singletoncopypackpackNpackN'packRpackRNpackRN'unpackunpackRlengthnullappendmapmap'imap'foldl'ifoldl'foldl1' foldl1Maybe'foldr'ifoldr'foldr1' foldr1Maybe'concat concatMapmaximum maximumMaybeminimum minimumMaybeproductproduct'anyallsumcount mapAccumL mapAccumR replicatecycleNunfoldrunfoldrNelemnotElem elemIndex mapIPair' fromIPairtoIPairdefaultChunkSizesmallChunkSize chunkOverheaddefaultInitSizeerrorEmptyVector errorOutRange castVector$fVecUnliftedArraya$fVecPrimArraya$fVecSmallArraya $fVecArraya$fHashable1Vector$fHashableVector$fCoArbitraryVector$fArbitraryVector$fTraversableVector$fFoldableVector$fFunctorVector $fReadVector $fShowVector$fNFDataVector$fMonoidVector$fSemigroupVector $fOrdVector $fEqVector$fIsListVector $fVecVectora$fIsListPrimVector$fIsStringPrimVector$fHashablePrimVector$fCoArbitraryPrimVector$fArbitraryPrimVector$fReadPrimVector$fShowPrimVector$fNFDataPrimVector$fMonoidPrimVector$fSemigroupPrimVector$fOrdPrimVector$fEqPrimVector$fVecPrimVectora$fFoldCasePrimVector$fHashablePrimVector0$fOrdPrimVector0 $fNFDataIPair$fFunctorIPair$fCoArbitraryIPair$fArbitraryIPair$fExceptionVectorException$fShowVectorException $fShowIPair $fEqIPair $fOrdIPairvecASCIIvecW8vecW16vecW32vecW64vecWordvecI8vecI16vecI32vecI64vecInt elemIndices findIndiceselemIndicesBytes findIndex findIndexRfindfindBytefindR findByteRfilter partitionindicesOverlappingindicesOverlappingBytesindices indicesBytes kmpNextTable sundayBloomelemSundayBloomconssnocunconsunsnoc headMaybe tailMayEmpty lastMaybe initMayEmptyinitstailstaketakeRdropdropRslicesplitAt takeWhile takeWhileR dropWhile dropWhileR dropAroundbreakspanbreakRspanRbreakOngroupgroupBy stripPrefix isPrefixOf commonPrefix stripSuffix isSuffixOf isInfixOfsplitsplitOn splitWithwordslinesunwordspadLeftpadRightreverse intersperse intercalateintercalateElem transposezipWith' unzipWith'scanl'scanl1'scanr'scanr1'rangeCutheadtailinitlastindexindexM modifyIndexmodifyIndexMaybe insertIndexinsertIndexMaybe deleteIndexdeleteIndexMaybe unsafeHead unsafeTail unsafeInit unsafeLast unsafeIndex unsafeIndexMunsafeModifyIndexunsafeInsertIndexunsafeDeleteIndex unsafeTake unsafeDrop TextExceptionInvalidUTF8ExceptionInvalidASCIIExceptionIndexOutOfTextRange EmptyTextText getUTF8Bytesc_ascii_validate_bac_utf8_validate_addrc_utf8_validate_ba charByteIndexindexR indexMaybeRcharByteIndexRvalidate validateMaybe validateASCIIvalidateASCIIMaybeerrorEmptyText fromVectortoVector isNormalizedisNormalizedTo normalize normalizeTocaseFold caseFoldWith toLowerWith toUpperWithtoTitle toTitleWith spanCategory displayWidthdisplayWidthChar$fFoldCaseText$fIsStringText$fHashableText$fCoArbitraryText$fArbitraryText $fNFDataText $fReadText $fShowText $fOrdText$fEqText $fIsListText$fExceptionTextException$fShowTextException $fMonoidText$fSemigroupTextfindBytesIndicesfindBytesIndexfindBytesIndexR breakOnAllBuilder runBuilder BuildResultDone BufferFull InsertBytes BuildStepBuffer freezeBufferstringModifiedUTF8charModifiedUTF8bytesbuild buildTextunsafeBuildText buildWith buildChunksbuildChunksWithensureNwriteN encodePrim encodePrimLE encodePrimBE stringUTF8charUTF8string7char7word7string8char8word8word8Ntextparen parenWhencurlysquareanglequotessquotescoloncommaintercalateVecintercalateList$fCoArbitraryBuilder$fArbitraryBuilder$fIsStringBuilder$fMonoidBuilder$fSemigroupBuilder$fMonadBuilder$fApplicativeBuilder$fFunctorBuilder $fShowBuilder RadixDownRadix bucketSizepassesradixLSBradixradixMSB mergeSort mergeSortBy mergeTileSize insertSort insertSortBy radixSortmergeDupAdjacentmergeDupAdjacentLeftmergeDupAdjacentRightmergeDupAdjacentBy $fRadixWord64 $fRadixWord32 $fRadixWord16 $fRadixWord $fRadixWord8 $fRadixInt64 $fRadixInt32 $fRadixInt16 $fRadixInt $fRadixInt8$fRadixRadixDown$fShowRadixDown $fEqRadixDown$fPrimRadixDown$fUnalignedRadixDown StdStringBAArray#MBA#BA#hs_delete_std_stringhs_copy_std_stringhs_std_string_sizeclearMBAwithPrimArrayUnsafewithPrimArrayListUnsafeallocPrimArrayUnsafewithPrimVectorUnsafeallocPrimVectorUnsafeallocBytesUnsafewithPrimUnsafeallocPrimUnsafewithPrimArraySafewithPrimArrayListSafeallocPrimArraySafewithPrimVectorSafe withPrimSafe allocPrimSafeallocPrimVectorSafeallocBytesSafe pinPrimArray pinPrimVectorclearPtrfromNullTerminatedfromPtr fromPrimPtr fromStdStringfromByteString toByteStringBase64DecodeExceptionIllegalBase64BytesIncompleteBase64Byteshs_base64_decodehs_base64_encode base64Encodebase64EncodeLengthbase64EncodeBuilderbase64EncodeText base64Decode base64Decode'base64DecodeLength $fExceptionBase64DecodeException$fShowBase64DecodeExceptionFFormatExponentFixedGenericPadding NoPaddingRightSpacePaddingLeftSpacePadding ZeroPaddingIFormatwidthpaddingposSigndefaultIFormatintintWith c_intWith hs_intWithinteger countDigitsi2wDeci2wHex i2wHexUpperhexhexUpperfloatdouble floatWith doubleWithgrisu3 grisu3_sp scientific scientific'scientificWith$fCoArbitraryPadding$fArbitraryPadding$fCoArbitraryIFormat$fArbitraryIFormat $fEnumFFormat $fReadFFormat $fShowFFormat $fShowIFormat $fEqIFormat $fOrdIFormat $fShowPadding $fEqPadding $fOrdPadding $fEnumPaddingday timeOfDaytimeZoneutcTime localTime zonedTimePrinttoUTF8BuilderP toUTF8Builder toUTF8BytestoTexttoStringescapeTextJSON $fGToTextkM1 $fGToTextkM10 $fGToTextk:+: $fGToTextkV1$fPrintSomeException$fPrintDayOfWeek$fPrintCalendarDiffDays$fPrintCalendarDiffTime$fPrintSystemTime$fPrintDiffTime$fPrintNominalDiffTime$fPrintTimeOfDay$fPrintLocalTime $fPrintDay$fPrintZonedTime$fPrintUTCTime$fPrintForeignPtr $fPrintPtr$fPrintCallStack $fPrintFixed $fPrintRatio $fPrintEither $fPrintMaybe$fPrint(,,,,,,)$fPrint(,,,,,) $fPrint(,,,,) $fPrint(,,,) $fPrint(,,) $fPrint(,)$fPrintPrimVector $fPrintVector$fPrintPrimArray$fPrintUnliftedArray$fPrintSmallArray $fPrintArray $fPrint[]$fPrintScientific $fPrintText$fPrintVersion $fPrint()$fPrintOrdering$fPrintNatural$fPrintInteger $fPrintWord64 $fPrintWord32 $fPrintWord16 $fPrintWord8 $fPrintWord $fPrintInt64 $fPrintInt32 $fPrintInt16 $fPrintInt8 $fPrintInt $fPrintFloat $fPrintDouble $fPrintChar $fPrintBool $fGToTextkK1 $fGToTextkM11 $fGToTextkM12$fGFieldToTextkM1$fGFieldToTextkM10$fGFieldToTextk:*: $fPrintSum$fPrintProduct$fPrintCompose $fPrintTagged $fPrintProxy $fPrintConst$fPrintIdentity$fPrintNonEmpty $fPrintLast $fPrintFirst $fPrintDual$fPrintWrappedMonoid $fPrintLast0 $fPrintFirst0 $fPrintMax $fPrintMin$fPrintExitCode$fPrintCDouble $fPrintCFloat$fPrintCSUSeconds$fPrintCUSeconds $fPrintCTime $fPrintCClock$fPrintCUIntMax$fPrintCIntMax$fPrintCUIntPtr$fPrintCIntPtr $fPrintCBool$fPrintCULLong $fPrintCLLong$fPrintCSigAtomic $fPrintCWchar $fPrintCSize$fPrintCPtrdiff $fPrintCULong $fPrintCLong $fPrintCUInt $fPrintCInt$fPrintCUShort $fPrintCShort $fPrintCUChar $fPrintCSChar $fPrintCCharFlatSet sortedValuessize packVector packVectorRinsertdeletemerge binarySearch$fCoArbitraryFlatSet$fArbitraryFlatSet$fNFDataFlatSet$fMonoidFlatSet$fSemigroupFlatSet$fPrintFlatSet $fShowFlatSet $fEqFlatSet $fOrdFlatSet$fFoldableFlatSetsortedKeyValueskmap'lookupadjust' mergeWithKey' foldrWithKey foldlWithKey foldrWithKey' foldlWithKey'traverseWithKey$fTraversableFlatMap$fFoldableFlatMap$fFunctorFlatMap$fNFDataFlatMap$fMonoidFlatMap$fSemigroupFlatMap$fCoArbitraryFlatMap$fArbitraryFlatMap$fPrintFlatMap $fShowFlatMap $fEqFlatMap $fOrdFlatMap FlatIntSet$fCoArbitraryFlatIntSet$fArbitraryFlatIntSet$fNFDataFlatIntSet$fMonoidFlatIntSet$fSemigroupFlatIntSet$fPrintFlatIntSet$fShowFlatIntSet$fEqFlatIntSet$fOrdFlatIntSet FlatIntMap$fTraversableFlatIntMap$fFoldableFlatIntMap$fFunctorFlatIntMap$fNFDataFlatIntMap$fMonoidFlatIntMap$fSemigroupFlatIntMap$fCoArbitraryFlatIntMap$fArbitraryFlatIntMap$fPrintFlatIntMap$fShowFlatIntMap$fEqFlatIntMap$fOrdFlatIntMap ParseChunksParser runParser ParseError ParseStepResultSuccessFailurePartial unsafeLiftIOfail' failWithInputparse'parse parseChunk finishParsing parseChunksrunAndKeepTrackmatch currentChunk endOfInputatEnd decodePrim decodePrimLE decodePrimBEscan scanChunks peekMaybepeeksatisfy satisfyWithanyWord8anyChar8anyChar7 anyCharUTF8 endOfLineskip skipWord8 skipWhile skipSpacestakeTill takeWhile1 takeRemainingtakeNbytesCI $fShowResult$fFunctorResult$fAlternativeParser$fMonadPlusParser$fMonadFailParser$fPrimMonadParser $fMonadParser$fApplicativeParser$fFunctorParserhex'hex_hexLoopw2iHexuint_uintdecLoopw2iDecdecLoopIntegerFastdigitint_rationalscientifically rational'double'float'scientifically'ValueObjectStringNumberBoolNullnthkey parseValue parseValue'valuearrayobjectstringfloatToScientificdoubleToScientific$fArbitraryValue $fNFDataValue $fEqValue $fOrdValue $fShowValue$fGenericValue $fPrintValuekvkv'array'object' prettyValue prettyValue' Converter runConverter ConvertErrorerrPatherrMsg PathElementKeyIndexEmbeddedconvertprependContext$fPrintConvertError$fShowConvertError$fMonadFailConverter$fMonadConverter$fMonadPlusConverter$fAlternativeConverter$fApplicativeConverter$fFunctorConverter$fEqConvertError$fOrdConvertError$fGenericConvertError$fNFDataConvertError$fEqPathElement$fShowPathElement$fOrdPathElement$fGenericPathElement$fNFDataPathElement gFromValue gEncodeJSONgToValueSettingsfieldFmt constrFmtmissingKeyAsNullKVItem DecodeErrorJSON fromValuetoValue encodeJSON decodeText' decodeTextdecode'decode decodeChunk decodeChunksencode encodeChunks encodeText convertValue prettyJSON typeMismatchfromNullwithBoolwithScientific withRealFloatwithBoundedScientificwithBoundedIntegralwithText withArray withKeyValues withFlatMap withFlatMapR withHashMap withHashMapRwithEmbeddedJSON.:.:?.:! convertFieldconvertFieldMaybeconvertFieldMaybe' commaSepList commaSepVec.!.=defaultSettings$fSemigroupKVItem $fGToValuekM1$fGToValuekM10$fGWriteFieldskM1$fGWriteFieldskM10$fGWriteFieldsTYPE:*:$fGMergeFieldskM1$fGMergeFieldskM10$fGMergeFieldsk:*:$fGToValuekM11$fGConstrToValueTYPEM1$fGConstrToValuekM1$fGConstrToValuekM10$fGConstrToValuek:+:$fGConstrToValuekV1$fGEncodeJSONk:*:$fGEncodeJSONkM1$fGEncodeJSONkM10$fGAddPunctuationM1$fGAddPunctuationM10$fGAddPunctuation:*:$fGEncodeJSONkM11$fGConstrEncodeJSONTYPEM1$fGConstrEncodeJSONkM1$fGConstrEncodeJSONkM10$fGConstrEncodeJSONkM11$fGConstrEncodeJSONk:+:$fGConstrEncodeJSONkV1$fGFromValuekM1$fGFromValuekM10 $fJSONFixed $fJSONRatio $fJSONMaybe$fJSON()$fJSONOrdering $fJSONNatural $fJSONInteger $fJSONWord64 $fJSONWord32 $fJSONWord16 $fJSONWord8 $fJSONWord $fJSONInt64 $fJSONInt32 $fJSONInt16 $fJSONInt8 $fJSONInt $fJSONFloat $fJSONDouble $fJSONChar $fJSONBool$fJSONNonEmpty$fJSON[] $fJSON[]0 $fJSONHashSet$fJSONPrimVector$fJSONPrimVector0 $fJSONVector$fJSONUnliftedArray$fJSONByteArray$fJSONPrimArray$fJSONSmallArray $fJSONArray $fJSONTree $fJSONSeq $fJSONSet $fJSONIntSet$fJSONFlatIntSet $fJSONIntMap$fJSONFlatIntMap $fJSONMap $fJSONHashMap $fJSONFlatSet $fJSONFlatMap$fJSONScientific $fJSONText $fJSONValue$fGFromValuekK1$fGEncodeJSONkK1 $fGToValuekK1$fGFromFieldskM1$fGFromFieldskM10$fGFromFieldsTYPE:*:$fGBuildLookupkM1$fGBuildLookupkM10$fGBuildLookupk:*:$fGFromValuekM11$fGConstrFromValueTYPEM1$fGConstrFromValuekM1$fGConstrFromValuekM10$fGConstrFromValuek:+:$fGConstrFromValuekV1 snakeCase trainCase $fJSONProxy$fJSONDayOfWeek$fJSONCalendarDiffDays$fJSONCalendarDiffTime$fJSONSystemTime$fJSONDiffTime$fJSONNominalDiffTime$fJSONTimeOfDay$fJSONLocalTime $fJSONDay$fJSONZonedTime $fJSONUTCTime $fJSONVersion$fJSONExitCode$fJSON(,,,,,,) $fJSON(,,,,,) $fJSON(,,,,) $fJSON(,,,) $fJSON(,,) $fJSON(,) $fJSONProduct $fJSONEither $fJSONSum $fJSONCDouble $fJSONCFloat$fJSONCSUSeconds$fJSONCUSeconds $fJSONCTime $fJSONCClock$fJSONCUIntMax $fJSONCIntMax$fJSONCUIntPtr $fJSONCIntPtr $fJSONCBool $fJSONCULLong $fJSONCLLong$fJSONCSigAtomic $fJSONCWchar $fJSONCSize$fJSONCPtrdiff $fJSONCULong $fJSONCLong $fJSONCUInt $fJSONCInt $fJSONCUShort $fJSONCShort $fJSONCUChar $fJSONCSChar $fJSONCChar $fJSONTagged $fJSONConst$fJSONIdentity $fJSONLast $fJSONFirst $fJSONDual$fJSONWrappedMonoid $fJSONLast0 $fJSONFirst0 $fJSONMax $fJSONMin $fJSONComposeHexDecodeExceptionIllegalHexBytesIncompleteHexBytesHexBytes unHexBytes hs_hex_decodehs_hex_encode_upper hs_hex_encode hexEncodehexEncodeBuilder hexEncodeText hexDecode hexDecode'$fJSONHexBytes$fPrintHexBytes$fShowHexBytes$fExceptionHexDecodeException$fShowHexDecodeException $fEqHexBytes $fOrdHexBytes$fMonoidHexBytes$fSemigroupHexBytes$fHashableHexBytes rawPrimArrayCB fromPrimArrayfromMutablePrimArray peekMBACBytes pokeMBACBytes indexBACBytestoBytestoBytes' fromBytes toTextMaybefromText toBuilder toBuilder' buildCBytes fromCString fromCStringNwithCBytesUnsafewithCBytesListUnsafe withCByteswithCBytesListallocCBytesUnsafe allocCBytes$fIsStringCBytes $fJSONCBytes $fPrintCBytes$fCoArbitraryCBytes$fArbitraryCBytes$fHashableCBytes$fMonoidCBytes$fSemigroupCBytes $fOrdCBytes $fEqCBytes$fNFDataCBytes $fReadCBytes $fShowCBytesCPtrnewCPtr' newCPtrUnsafenewCPtrwithCPtrwithCPtrsUnsafe withCPtrs $fPrintCPtr $fShowCPtr $fOrdCPtr$fEqCPtrRegexExceptionInvalidRegexPattern RegexOpts posix_syntax longest_matchmax_memliteralnever_nldot_nl never_capturecase_sensitive perl_classes word_boundaryone_lineRegexregexCaptureNum regexPatterndefaultRegexOptsregex regexOptsescapetestreplaceextract$fExceptionRegexException$fShowRegexException $fEqRegexOpts$fOrdRegexOpts$fShowRegexOpts$fGenericRegexOpts$fPrintRegexOpts $fShowRegex$fGenericRegex $fPrintRegexGHC.WordWord8 GHC.TypesCharMutableByteArray#TYPE UnliftedRep ArrayArray# indexArray indexArrayMGHC.IntInt8Word16Int16Word32Int32Word64Int64WordIntAddr#template-haskellLanguage.Haskell.TH.SyntaxLitE GHC.MaybeNothingGHC.BaseFunctorseqJustTrueGHC.ListzipWithscanlscanrGHC.ShowShow Data.StringIsStringshrinkMutablePrimArray GHC.ClassesOrd ByteArray#bytestring-0.10.10.0Data.ByteString.Internal ByteStringForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCBoolCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxcopyPtrToMutableByteArraysetPtrmovePtrcopyPtr writeOffPtr readOffPtr indexOffPtr subtractPtr advancePtrcloneMutablePrimArrayclonePrimArrayitraversePrimArray_traversePrimArray_replicatePrimArrayAgeneratePrimArrayAreplicatePrimArraygeneratePrimArrayitraversePrimArrayPitraversePrimArraytraversePrimArraymapMaybePrimArraymapMaybePrimArrayAfilterPrimArrayAfilterPrimArray imapPrimArray mapPrimArrayreplicatePrimArrayPgeneratePrimArrayPmapMaybePrimArrayPfilterPrimArrayPtraversePrimArrayPfoldlPrimArrayM'foldlPrimArray'foldlPrimArrayfoldrPrimArray'foldrPrimArraysizeofPrimArrayindexPrimArrayunsafeThawPrimArrayunsafeFreezePrimArrayfreezePrimArraysameMutablePrimArraysizeofMutablePrimArraygetSizeofMutablePrimArray setPrimArray copyPrimArraycopyMutablePrimArraywritePrimArray readPrimArrayresizeMutablePrimArray newPrimArrayprimArrayToListprimArrayFromListNprimArrayFromListData.Primitive.ByteArraycloneMutableByteArraycloneByteArraycompareByteArrays fillByteArray setByteArray moveByteArraycopyMutableByteArrayToAddrcopyByteArrayToAddrcopyMutableByteArrayToPtrcopyByteArrayToPtrcopyMutableByteArray copyByteArraybyteArrayFromListNbyteArrayFromListfoldrByteArraywriteByteArray readByteArrayindexByteArrayisMutableByteArrayPinnedisByteArrayPinnedshrinkMutableByteArraysizeofMutableByteArraysizeofByteArrayunsafeThawByteArrayunsafeFreezeByteArrayfreezeByteArraygetSizeofMutableByteArrayresizeMutableByteArraysameMutableByteArraymutableByteArrayContentsbyteArrayContentsnewAlignedPinnedByteArraynewPinnedByteArray newByteArray ByteArrayMutableByteArrayGHC.EnumBoundedGHC.RealIntegralinteger-wired-inGHC.Integer.TypeInteger Data.Bits FiniteBitsFloatDouble time-1.9.3 Data.Time.Clock.Internal.UTCTimeUTCTime&Data.Time.LocalTime.Internal.LocalTime LocalTime&Data.Time.LocalTime.Internal.ZonedTime ZonedTimeshow Data.EitherRightLeftData.TraversabletraverseMonadIOControl.Monad.FailfailFalse Text.Readread)scientific-0.3.7.0-IjvAzRFEzKW4AZZ4kLP1wfData.Scientific Scientific GHC.NaturalNatural!Data.Time.Clock.Internal.DiffTimeDiffTime(Data.Time.Clock.Internal.NominalDiffTimeNominalDiffTime Data.Version versionBranch