h$nQ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                              ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % % % % % % & & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * *****/ ASCII chars(c) Dong Han, 2020BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?(=-Z-Data \DEL.Z-Data ~/Z-Data }0Z-Data }1Z-Data |2Z-Data |3Z-Data {4Z-Data {OZ-Data `PZ-Data _QZ-Data ^RZ-Data ]SZ-Data ]TZ-Data \UZ-Data [VZ-Data [qZ-Data @rZ-Data ?sZ-Data >tZ-Data >uZ-Data =vZ-Data  \255.Z-Data \NUL <= w && w <= \DELZ-Data A ~ ZZ-Data a ~ zZ-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 ~ f-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-Primitive casting+Haskell Foundation, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?+=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:<>?3Z-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:<>?=Z-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:<>?Qe!Z-DataA typeclass to unify box & unboxed, mutable & immutable array operations.Most of these functions simply wrap their primitive counterpart, if there's no primitive ones, we polyfilled using other operations to get the same semantics.One exception is that " only perform closure resizing on ) because current RTS support only that, % will do nothing on other array type.It's reasonable to trust GHC with specializing & inlining these polymorphric functions. They are used across this package and perform identical to their monomophric counterpart.Z-Data#Mutable version of this array type.Z-Data!Make a new array with given size."For boxed array, all elements are  which shall not be accessed. For primitive array, elements are just random garbage.Z-Data3Make a new array and fill it with an initial value.Z-Data)Index mutable array in a primitive monad.Z-Data)Write mutable array in a primitive monad.Z-Data&Fill mutable array with a given value.Z-DataIndex immutable array, which is a pure operation. This operation often result in an indexing thunk for lifted arrays, use 'indexArr'' or  if that's not desired.Z-DataIndex immutable array, pattern match on the unboxed unit tuple to force indexing (without forcing the element).Z-DataIndex immutable array in a primitive monad, this helps in situations that you want your indexing result is not a thunk referencing whole array.Z-DataSafely freeze mutable array by make a immutable copy of its slice.Z-DataSafely thaw immutable array by make a mutable copy of its slice.Z-DataIn place freeze a mutable array, the original mutable array can not be used anymore.Z-DataIn place thaw a immutable array, the original immutable array can not be used anymore.Z-DataCopy a slice of immutable array to mutable array at given offset.Z-DataCopy a slice of mutable array to mutable array at given offset. The two mutable arrays shall no be the same one.Z-DataCopy a slice of mutable array to mutable array at given offset. The two mutable arrays may be the same one.Z-DataCreate immutable copy.Z-DataCreate mutable copy.Z-Data#Resize mutable array to given size.Z-DataShrink mutable array to 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 immutable array.Z-DataSize of mutable array.Z-Data4Is two immutable array are referencing the same one. Note that  's result 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 background.Z-DataBottom value (throw ( +,)") for initialize new boxed array((, #..).Z-Data?Yield a pointer to the array's data and do computation with it.This operation is only safe on pinned primitive arrays allocated by   or  .0Don't pass a forever loop to this function, see  -https://ghc.haskell.org/trac/ghc/ticket/14346#14346.Z-Data?Yield a pointer to the array's data and do computation with it.This operation is only safe on pinned primitive 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 array's element at given index to produce a new array.Z-DataInsert an immutable array's element at given index to produce a new array.Z-DataDelete an immutable array's element at given index to produce a new array.Z-DatatargetZ-Data target offsetZ-DatasourceZ-Data source offsetZ-Data source lengthZ-DatatargetZ-Data target offsetZ-DatasourceZ-Data source offsetZ-Data source lengthZ-DatatargetZ-Data target offsetZ-DatasourceZ-Data source offsetZ-Data source lengthZ-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 ! #"%$('&+*)('&+*)#"%$!    *Extra stuff for PrimArray related literals(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?ZZ-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:<>?^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:<>?` 0Compute Generic product size during compile time(c) Dong Han, 2017-2020BSDwinterland1989@gmail.com experimental non-portableNone-  #$&-./289:<>?aZ-Data(type class for calculating product size. Primitive ST Reference(c) Dong Han 2017~2019 BSD-stylewinterland1989@gmail.com experimentalportableNone,  #$&-./289:<>?cZ-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:<>?j[Z-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:<>?kjUTF-8 codecs and helpers.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?wZ-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:<>?KZ-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-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:<>?  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 n.Z-DataO(n) Joins words with ascii space.Z-DataO(n) Joins lines with ascii n.'NOTE: This functions is different from /0, 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:<>?!: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?)' 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:<>?Ia4Z-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 /0, 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 search55 Efficient deserialization/parse.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?`*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 inp -> -- fail continuation, success continuation and input ... ... kf errMsg (if input not OK) ... k ... (if we get something useful for next parser) Z-DataType alias for error messageZ-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-Data version of .Z-Data-Parse the complete input, without resupplyingZ-DataParse the complete input, without resupplying, return the rest bytesZ-DataParse an input chunkZ-Data:Finish parsing and fetch result, feed empty bytes if it's  result.Z-DataRun a parser with an initial input string, and a monadic action that can supply more input if needed.Note, once the monadic action return empty bytes, parsers will stop drawing more bytes (take it as ).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-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 <= 57Z-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-Data&Take a byte and return as a 8bit char.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 inputZ-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 case.Z-Datatext s8 parses a sequence of UTF8 bytes that identically match s.770Textual numeric parsers.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?wZ-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-6Z-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 0Z-Data!accumulator, usually start from 0Sorting vectors/(c) 2008-2011 Dan Doel, (c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?Z-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 right1Fast boxed and unboxed vector(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?Parsers for types from time.=(c) 2015-2016 Bryan O'Sullivan (c) 2020 Dong HanBSD3Dong  experimentalportableNone,  #$&-./289:<>?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.2 Efficient deserialization/parse.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?#Use PrimArray / PrimVector with FFI(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?Z-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 3 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  ,$,Efficient serialization/format.;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?&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 45 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 list44Base64 codec for bytes.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>? Z-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:<>?m Z-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 options Z-Datapadding options Z-Datashow + when the number is positive Z-Data *defaultIFormat = IFormat 0 NoPadding False Z-Data int = intWith defaultIFormat Z-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.buildBytes $ B.hex (125 :: Int8) "7d" > T.validate . B.buildBytes $ B.hex (-1 :: Int8) "ff" > T.validate . B.buildBytes $ 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-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." " UTF8 compatible builders.(c) Dong Han, 2017-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?0 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.buildBytes (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-DataAdd "(..)" around builders when condition is met, otherwise add nothing.This is useful when defining   instances. 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 The escaping rules is same with  instance: we reuse JSON escaping rules here, so it will be faster. Z-DataConstructor with payloads1 1   Fast set based on sorted vector;(c) Dong Han, 2017-2019 (c) Tao He, 2018-2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?K 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:<>? 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:<>?4 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.  # 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-Datarewrite Z-DatainputZ-Dataextract  4Unicode text processing(c) Dong Han, 2017-2020BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>??  $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. 168Roundtrip 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-DataIncreamental parse  " without consuming trailing bytes. 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 91. Z-Data"parse json array with leading 123. Z-Data*Convert IEEE float to scientific notition. Z-Data+Convert IEEE double to scientific notition.  %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.  7Efficient serialization/format.(c) Dong Han, 2017-2018BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?   & JSON representation and builders(c) Dong Han, 2019BSDwinterland1989@gmail.com experimental non-portableNone,  #$&-./289:<>?( 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-DataThis builder try to render integer when (0 <= e < 16), and scientific notation otherwise. 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:<>?.d 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:<>?H9 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-Data.Decode JSON doc chunks, return trailing bytes. Z-Data#Directly encode data to JSON bytes. 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:<>?O% 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:<>?S# Z-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:<>?m"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 Constuctor a < from arbitrary array, result will be trimmed down to first \NUL byte if there's any.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 .Z-DataO(1) , convert to /, which can be processed by vector combinators.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-DataBuild a 4 with builder, result will be trimmed down to first \NUL byte if there's any.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,"#89:;<=;>?;>@;>A;BC;BD;BD;EFGHIGJKGJLGJMGJNGJOGJPGJQGJRGJSGJSGJTGJTGUVGUWGUXGUYGUZGU[GU\GU]GU^GU_GU`GUaGbcGbcGbdGbdGefGegGegGehGeiGeiGjklmnopqrstuvwxyz{|}~,                                                    N M R Q I                 0.0                                                                                                      6          ! ! ! !!!!!!!!!! ! !! ! ! ! ! ! ! ! ! ! ! ! ! " " " """"""""""" " " " " " " " " " " " " " " " " " " " " " " " " " # # # # # # # # # # # # # # # # # # # # # # # ## # # # # # # # # # # # $ $ $g$ $ $ $ $ $ $ $ $ $$ $ $ $ $ $ $ $ $ $ $ $ $ %%%%%%& & & & & & & & && & ' ' ' ' ' ' ' ' ' ' ' ' ''' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * * * * * * 3                                 ;  8  89 89 8  89 ;  ;  ;  ;  ;  ;  ;  8  8  89  ;  ;  ;  89 ;  8  ; ; ; ;  ;  ; 8   8  ; 8  8  89 ;E  ;E ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;E GH GH GH GH GH GH GH GH GH GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ GJ G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G ;;;;; ;;;; ;;%Z-Data-0.6.1.0-JeXatJjxwtL6zC0T0lLei4 Z.Data.Array 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.Parser.BaseZ.Data.Parser.NumericZ.Data.Parser.TimeZ.Data.Builder.BaseZ.Data.Vector.Base64Z.Data.Builder.NumericZ.Data.Text.PrintZ.Data.Vector.FlatSetZ.Data.Vector.FlatMapZ.Data.Vector.FlatIntSetZ.Data.Vector.FlatIntMapZ.Data.Text.RegexZ.Data.JSON.ValueZ.Data.Builder.TimeZ.Data.JSON.BuilderZ.Data.JSON.ConverterZ.Data.JSON.Base Z.Data.JSONZ.Data.Vector.Hex Data.Array uninitializedZ.Data.PrimRef isCategoryPreludeunlines Z.Data.Vector Z.Data.ParserCBytes Z.Data.TextShowTFlatMapZ.Data.Builderghc-primGHC.Prim RealWorldbaseForeign.C.StringCStringGHC.IO.ExceptionUndefinedElementIndexOutOfBoundsArrayExceptionData.OrdgetDownDownGHC.PtrcastPtr'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 QUOTE_SINGLEAND AMPERSANDPERCENTDOLLAR NUMBER_SIGNHASH QUOTE_DOUBLEEXCLAMSPACECARRIAGE_RETURN FORM_FEED VERTICAL_TABNEWLINETABNULw2cc2wisASCIIisUpperisLower 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 castArraycastMutableArray singletonArr doubletonArrmodifyIndexArrinsertIndexArrdeleteIndexArr$fArrUnliftedArraya$fArrPrimArraya$fArrSmallArraya $fArrArraya asciiLiteralarrASCIIword8ArrayFromAddrint8ArrayFromAddr utf8Literal arrayLiteral word8LiteralarrW8 int8LiteralarrI8 word16LiteralarrW16word16ArrayFromAddrint16ArrayFromAddr int16LiteralarrI16 word32LiteralarrW32word32ArrayFromAddrint32ArrayFromAddr int32LiteralarrI32 word64LiteralarrW64word64ArrayFromAddrint64ArrayFromAddr int64LiteralarrI64wordArrayFromAddrintArrayFromAddr wordLiteral intLiteralarrWordarrInt decDigitTable hexDigitTablehexDigitTableUpper ProductSizePSize productSize$fProductSize:*:$fProductSizeM1 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 $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 caseFoldWithtoLower toLowerWithtoUpper toUpperWithtoTitle toTitleWith spanCategory displayWidth$fFoldCaseText$fIsStringText$fHashableText$fCoArbitraryText$fArbitraryText $fNFDataText $fReadText $fShowText $fOrdText$fEqText $fIsListText$fExceptionTextException$fShowTextException $fMonoidText$fSemigroupTextfindBytesIndicesfindBytesIndexfindBytesIndexR breakOnAll ParseChunksParser runParser ParseError ParseStepResultSuccessFailurePartialfail'parse'parse parseChunk finishParsing parseChunksrunAndKeepTrackmatchensureN endOfInputatEnd decodePrim decodePrimLE decodePrimBEscan scanChunks peekMaybepeeksatisfy satisfyWithword8anyWord8char8anyChar8 endOfLineskip skipWord8 skipWhile skipSpacestakeTill takeWhile1 takeRemainingtakeNbytesbytesCItext $fShowResult$fFunctorResult$fAlternativeParser$fMonadPlusParser$fMonadFailParser $fMonadParser$fApplicativeParser$fFunctorParserhexhex'hex_hexLoopw2iHexuint_uintdecLoopw2iDecdecLoopIntegerFastdigitintint_integerrationaldoublefloat scientificscientifically rational'double'float' scientific'scientifically' RadixDownRadix bucketSizepassesradixLSBradixradixMSB mergeSort mergeSortBy mergeTileSize insertSort insertSortBy radixSortmergeDupAdjacentmergeDupAdjacentLeftmergeDupAdjacentRightmergeDupAdjacentBy $fRadixWord64 $fRadixWord32 $fRadixWord16 $fRadixWord $fRadixWord8 $fRadixInt64 $fRadixInt32 $fRadixInt16 $fRadixInt $fRadixInt8$fRadixRadixDown$fShowRadixDown $fEqRadixDown$fPrimRadixDown$fUnalignedRadixDownday timeOfDaytimeZone localTimeutcTime zonedTime StdStringBAArray#MBA#BA#hs_delete_std_stringhs_copy_std_stringhs_std_string_sizeclearMBAwithPrimArrayUnsafewithPrimArrayListUnsafeallocPrimArrayUnsafewithPrimVectorUnsafeallocPrimVectorUnsafeallocBytesUnsafewithPrimUnsafeallocPrimUnsafewithPrimArraySafewithPrimArrayListSafeallocPrimArraySafewithPrimVectorSafe withPrimSafe allocPrimSafeallocPrimVectorSafeallocBytesSafe pinPrimArray pinPrimVectorclearPtrfromNullTerminatedfromPtr fromPrimPtr fromStdStringfromByteString toByteStringBuilder runBuilder BuildResultDone BufferFull InsertBytes BuildStepBuffer freezeBufferstringModifiedUTF8charModifiedUTF8build buildTextunsafeBuildText buildWith buildChunksbuildChunksWithwriteN encodePrim encodePrimLE encodePrimBE stringUTF8charUTF8string7char7word7string8word8NparencurlysquareanglequotessquotescoloncommaintercalateVecintercalateList$fCoArbitraryBuilder$fArbitraryBuilder$fIsStringBuilder$fMonoidBuilder$fSemigroupBuilder$fMonadBuilder$fApplicativeBuilder$fFunctorBuilder $fShowBuilderBase64DecodeExceptionIllegalBase64BytesIncompleteBase64Byteshs_base64_decodehs_base64_encode base64Encodebase64EncodeLengthbase64EncodeBuilderbase64EncodeText base64Decode base64Decode'base64DecodeLength $fExceptionBase64DecodeException$fShowBase64DecodeExceptionFFormatExponentFixedGenericPadding NoPaddingRightSpacePaddingLeftSpacePadding ZeroPaddingIFormatwidthpaddingposSigndefaultIFormatintWith c_intWith hs_intWith countDigitsi2wDeci2wHex i2wHexUpperhexUpper floatWith doubleWithgrisu3 grisu3_spscientificWith$fCoArbitraryPadding$fArbitraryPadding$fCoArbitraryIFormat$fArbitraryIFormat $fEnumFFormat $fReadFFormat $fShowFFormat $fShowIFormat $fEqIFormat $fOrdIFormat $fShowPadding $fEqPadding $fOrdPadding $fEnumPaddingPrinttoUTF8BuilderP toUTF8Builder toUTF8BytestoTexttoString parenWhenescapeTextJSON $fGToTextkM1 $fGToTextkM10 $fGToTextk:+: $fGToTextkV1$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$fOrdFlatIntMapRegexExceptionInvalidRegexPattern 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 $fPrintRegexValueObjectStringNumberBoolNullnthkey parseValue parseValue'parseValueChunksvaluearrayobjectstringfloatToScientificdoubleToScientific$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 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 fromPrimArray peekMBACBytes pokeMBACBytes indexBACBytestoBytes fromBytes toTextMaybefromText toBuilder buildCBytes fromCString fromCStringNwithCBytesUnsafewithCBytesListUnsafe withCByteswithCBytesListallocCBytesUnsafe allocCBytes$fIsStringCBytes $fJSONCBytes $fPrintCBytes$fCoArbitraryCBytes$fArbitraryCBytes$fHashableCBytes$fMonoidCBytes$fSemigroupCBytes $fOrdCBytes $fEqCBytes$fNFDataCBytes $fReadCBytes $fShowCBytesGHC.WordWord8 GHC.TypesCharMutableByteArray#TYPE UnliftedRep ArrayArray#GHC.IntInt8Word16Int16Word32Int32Word64Int64WordIntAddr#template-haskellLanguage.Haskell.TH.SyntaxLitE GHC.MaybeNothingGHC.BaseFunctorseqJustTrueGHC.ListzipWithscanlscanrGHC.ShowShowMonadControl.Monad.FailfailFalseinteger-wired-inGHC.Integer.TypeIntegerDouble Text.ReadreadFloat GHC.ClassesOrd ByteArray#Ptrbytestring-0.10.10.0Data.ByteString.Internal ByteStringForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCBoolCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxnullPtrcopyPtrToMutableByteArraysetPtrmovePtrcopyPtr writeOffPtr readOffPtr indexOffPtr subtractPtr advancePtrcloneMutablePrimArrayclonePrimArrayitraversePrimArray_traversePrimArray_replicatePrimArrayAgeneratePrimArrayAreplicatePrimArraygeneratePrimArrayitraversePrimArrayPitraversePrimArraytraversePrimArraymapMaybePrimArraymapMaybePrimArrayAfilterPrimArrayAfilterPrimArray imapPrimArray mapPrimArrayreplicatePrimArrayPgeneratePrimArrayPmapMaybePrimArrayPfilterPrimArrayPtraversePrimArrayPfoldlPrimArrayM'foldlPrimArray'foldlPrimArrayfoldrPrimArray'foldrPrimArraysizeofPrimArrayindexPrimArrayunsafeThawPrimArrayunsafeFreezePrimArrayfreezePrimArraysameMutablePrimArraysizeofMutablePrimArraygetSizeofMutablePrimArray setPrimArray copyPrimArraycopyMutablePrimArraywritePrimArray readPrimArrayshrinkMutablePrimArrayresizeMutablePrimArray newPrimArrayprimArrayToListprimArrayFromListNprimArrayFromListData.Primitive.ByteArraycloneMutableByteArraycloneByteArraycompareByteArrays fillByteArray setByteArray moveByteArraycopyMutableByteArrayToAddrcopyByteArrayToAddrcopyMutableByteArrayToPtrcopyByteArrayToPtrcopyMutableByteArray copyByteArraybyteArrayFromListNbyteArrayFromListfoldrByteArraywriteByteArray readByteArrayindexByteArrayisMutableByteArrayPinnedisByteArrayPinnedshrinkMutableByteArraysizeofMutableByteArraysizeofByteArrayunsafeThawByteArrayunsafeFreezeByteArrayfreezeByteArraygetSizeofMutableByteArrayresizeMutableByteArraysameMutableByteArraymutableByteArrayContentsbyteArrayContentsnewAlignedPinnedByteArraynewPinnedByteArray newByteArray ByteArrayMutableByteArray Data.StringIsStringGHC.EnumBoundedGHC.RealIntegral Data.Bits FiniteBitsshow Data.EitherRightLeftData.Traversabletraverse time-1.9.3 Data.Time.Clock.Internal.UTCTimeUTCTime&Data.Time.LocalTime.Internal.LocalTime LocalTime&Data.Time.LocalTime.Internal.ZonedTime ZonedTime)scientific-0.3.6.2-JrPABUT0PogB60SafKIOdFData.Scientific Scientific GHC.NaturalNatural!Data.Time.Clock.Internal.DiffTimeDiffTime(Data.Time.Clock.Internal.NominalDiffTimeNominalDiffTime Data.Version versionBranch