(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv w x y z { | } ~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        FSafe $*,-/69:;<=?ABCDMOQRTb Common display formats.&How a given value should be displayed.%Display a string with the given mode.4Examine a string to decide how we should display it.6Left justify some text in a column of the given width.7Right justify some text in a column of the given width.     Safe $*,-/69:;<=?ABCDMOQRTb.Unpack the pieces of a structure into a tuple.bThis is used in a low-level fusion optimisation to ensure that intermediate values are unboxed.!Safe $*,-/69:;<=?ABCDMOQRTb$1Our index type, used for both shapes and indices.&An index of dimension zero(<Class of types that can be used as array shapes and indices.)(Get the number of dimensions in a shape.*GThe shape of an array of size zero, with a particular dimensionality.+IThe shape of an array with size one, with a particular dimensionality.,'Compute the intersection of two shapes.-/Add the coordinates of two shapes componentwise.=Get the total number of elements in an array with this shape./LGiven a starting and ending index, check if some index is with that range.0,Convert a shape into its list of dimensions.1'Convert a list of dimensions to a shape2HGiven an array shape and index, check whether the index is in the shape.3!Nicely format a shape as a string !"#$%&'()*+,-./0123456789 !"#$%&'(.)*+,-/0123456789 !"#$%&'( )*+,-./0123456789$3%3"Safe $*,-/69:;<=?ABCDMOQRTb;BA layout provides a total order on the elements of an index space._We can talk about the n-th element of an array, independent of its shape and dimensionality.<NShort name for a layout which does not include details of the exact extent.=*Type used to index into this array layout.> O(1). Proxy for the layout name.?2O(1). Create a default layout of the given extent.@%O(1). Yield the extent of the layout.A2O(1). Convert a polymorphic index to a linear one.B2O(1). Convert a linear index to a polymorphic one. :;<=>?@AB :;<=?>@AB:;<=>?@AB#Safe $*,-/69:;<=?ABCDMOQRTb C8Constraint synonym that requires an integer index space.D]Class of array representations that we can read elements from in a random-access manner. E%An Array supplies an element of type a? to each position in the index space associated with layout l.F!O(1). Get the layout of an array.GO(1). Get an element from an array. If the provided index is outside the extent of the array then the result depends on the layout.HO(1). Alias for G.I-O(1). Get the number of elements in an array.J:O(1). Take the first element of an array, if there is one.LConvert an array to a list.%Convert a nested array to some lists.6Convert a triply nested array to a triply nested list. CDEFGHIJKL Source array. Result list. Source array. Result list. CDEGFHIJKL CDEFGHIJKLSafe $*,-/69:;<=?ABCDMOQRTb% !"#$%&'(.)*+,-/0123456789:;<=?>@AB%()*+,-./0123&'$%#"! 456789;<=>?@AB:Safe $*,-/69:;<=?ABCDMOQRTbM,Class of index types that can map to slices.N9Map an index of a full shape onto an index of some slice.O8Map an index of a slice onto an index of the full shape.PRMap the type of an index in the slice, to the type of the index in the full shape.QQMap a type of the index in the full shape, to the type of the index in the slice.R$Place holder for any possible shape.T)Select all indices at a certain position. MNOPQRSTUVWXY MNOPQRSTU TURSQPMNO MNOPQRSTUVWXYSafe $*,-/69:;<=?ABCDMOQRTbZ=Class of array representations that can be windowed directly.qThe underlying representation can encode the window, without needing to add a wrapper to the existing layout.a&Wrap a window around an exiting array.bHWrap a window around an existing array that encompases the entire array.c$O(1). Take the tail of an array, or  if it's empty.d0O(1). Take the initial elements of an array, or  if it's empty.eWindows are windowable.fWindowed arrays.gWindowed arrays.Z[\]^_`abcdefg EZ[\]^_`abcd \]^_`Z[abcd Z[\]^_`abcdefgSafe $*,-/69:;<=?ABCDMOQRTbl6A linear layout with the elements indexed by integers.`Indexing is not bounds checked. Indexing outside the extent yields the corresponding index.oTConstruct a linear array that produces the corresponding index for every element. 6> toList $ linear 10 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]pLinear arrays.qLinear layout. lmn  o p q< E lmnolmnolmnop  q  $Safe $*,-/69:;<=?ABCDMOQRTb     None $*,-/69:;<=?ABCDMOQRTb{WA row-wise layout that maps higher rank indices to linear ones in a row-major order.HIndices are ordered so the inner-most coordinate varies most frequently: > Prelude.map (fromIndex (RowWise (ish2 2 3))) [0..5] [(Z :. 0) :. 0, (Z :. 0) :. 1, (Z :. 0) :. 2, (Z :. 1) :. 0, (Z :. 1) :. 1, (Z :. 1) :. 2]aIndexing is not bounds checked. Indexing outside the extent yields the corresponding index.~UConstruct a rowWise array that produces the corresponding index for every element. > toList $ rowWise (ish2 3 2) [(Z :. 0) :. 0, (Z :. 0) :. 1, (Z :. 1) :. 0, (Z :. 1) :. 1, (Z :. 2) :. 0, (Z :. 2) :. 1]Row-wise arrays.vwxyz{|}~<Evwxyz{|}~{|}~zyxwvvwxyz{|}~%None $*,-/69:;<=?ABCDMOQRTb8Constraint synonym that requires an integer index space.]Class of manifest array representations that can be constructed in a random-access manner.-Mutable buffer for some array representation.3Allocate a new mutable buffer for the given layout.>UNSAFE: The integer must be positive, but this is not checked.(Read an element from the mutable buffer.)UNSAFE: The index bounds are not checked.)Write an element into the mutable buffer.)UNSAFE: The index bounds are not checked.VO(n). Copy the contents of a buffer that is larger by the given number of elements.>UNSAFE: The integer must be positive, but this is not checked.2O(1). Yield a slice of the buffer without copying.UNSAFE: The given starting position and length must be within the bounds of the of the source buffer, but this is not checked.;O(1). Freeze a mutable buffer into an immutable Repa array.UNSAFE: If the buffer is mutated further then the result of reading from the returned array will be non-deterministic.*O(1). Thaw an Array into a mutable buffer.+UNSAFE: The Array is no longer safe to use.{Ensure the array is still live at this point. Sometimes needed when the mutable buffer is a ForeignPtr with a finalizer.#O(1). Get the layout from a Buffer.)O(1). An empty array of the given layout.;O(1). Create a new empty array containing a single element.@O(length src). Construct a linear array from a list of elements.^O(length src). Construct an array from a list of elements, and give it the provided layout.The IB of the provided shape must match the length of the list, else .NApply a function to every element of an array, if any application returns , then  for the whole result.NApply a function to every element of an array, if any application returns , then  for the whole result.uGenerate an array of the given length by applying a function to every index, sequentially. If any element returns  , then  for the whole array.uGenerate an array of the given length by applying a function to every index, sequentially. If any element returns  , then  for the whole array.>Unfold a new array using the given length and worker function. This is like generateEitherO, except that an accumulator is threaded sequentially through the elements.Destination format. Length of array. Worker function.Starting accumluator &None $*,-/69:;<=?ABCDMOQRTbfCompute all elements defined by a delayed array and write them to a manifest target representation.The instances of this class require that the source array has a delayed representation. If you want to use a pre-existing manifest array as the source then delay it first."Fill an entire array sequentially.!Fill an entire array in parallel. None $*,-/69:;<=?ABCDMOQRTb1Sequential computation of delayed array elements.nElements of the source array are computed sequentially and written to a new array of the specified layout.Like ( but use the provided desination layout.TThe size of the destination layout must match the size of the source array, else . None $*,-/69:;<=?ABCDMOQRTb'None $*,-/69:;<=?ABCDMOQRTb=Keep the elements of an array that match the given predicate. None $*,-/69:;<=?ABCDMOQRTb1Layout an array as flat vector of boxed elements.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well.&O(1). Wrap a boxed vector as an array.*O(1). Unwrap a boxed vector from an array.Scan through an array from front to back. For pairs of successive elements, drop the second one when the given predicate returns true.CThis function can be used to remove duplicates from a sorted array.&TODO: generalise to other array types.Boxed buffers.Boxed windows. Boxed arrays. Boxed arrays. !"# < E !"# None $*,-/69:;<=?ABCDMOQRTbrDelayed arrays wrap functions from an index to element value. The index space is specified by an inner layout, l.XEvery time you index into a delayed array the element at that position is recomputed.#Wrap a function as a delayed array. S> toList $ fromFunction (Linear 10) (* 2) = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]SProduce the extent of an array, and a function to retrieve an arbitrary element.(Wrap an existing array in a delayed one.bApply a worker function to each element of an array, yielding a new array with the same extent.qThe resulting array is delayed, meaning every time you index into it the element at that index is recomputed. 5O(1). View the elements of a vector in reverse order. H> toList $ reverse $ fromList U [0..10 :: Int] [10,9,8,7,6,5,4,3,2,1,0] Delayed arrays.Delayed arrays.$%&' E$ &$'%(None $*,-/69:;<=?ABCDMOQRTb  Layout for dense Foreign arrays.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well.<O(1). Cast a foreign array from one element type to another. O(1). Wrap a ( as an array.O(1). Unwrap a ( from an array.,O(1). Convert a foreign array to a storable Vector.O(1). Convert a storable Vector to a foreign EO(1). Convert a foreign Vector to a ).O(1). Convert a ) to an foreign E.*Foreign buffers+Windowing Foreign arrays.,Foreign arrays.-Foreign arrays../012*+3,4-<0E$/. 1*2.+,3/-40None $*,-/69:;<=?ABCDMOQRTb5Layout an array as a flat vector of unboxed elements.=This is the most efficient representation for numerical data.The implementation uses Data.Vector.Unboxed which picks an efficient, specialised representation for every element type. In particular, unboxed vectors of pairs are represented as pairs of unboxed vectors.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well.)O(1). Wrap an unboxed vector as an array.-O(1). Unwrap an unboxed vector from an array.Unboxed buffers.Windowing Unboxed arrays.Unboxed arrays.Unboxed arrays.56789: <7E6$5 8596:7)None $*,-/69:;<=?ABCDMOQRTb/Dictionaries needed to perform a concatenation.(O(len result) Concatenate nested arrays. > import Data.Repa.Array.Material > let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]] > toList $ concat U arrs [1,2,3,5,6,7] O(len result) Concatenate the elements of some nested vector, inserting a copy of the provided separator array between each element. > import Data.Repa.Array.Material > let sep = fromList U [0, 0, 0] > let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]] > toList $ concatWith U sep arrs [1,2,3,0,0,0,5,6,7,0,0,0] O(len result). Perform a ?, adding a newline character to the end of each inner array.tO(len result) Insert a copy of the separator array between the elements of the second and concatenate the result. > import Data.Repa.Array.Material > let sep = fromList U [0, 0, 0] > let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]] > toList $ intercalate U sep arrs [1,2,3,0,0,0,5,6,7] Layout for destination.Arrays to concatenate.;Result representation.Separator array.Arrays to concatenate.Result representation.Arrays to concatenate.Result representation.Separator array.Arrays to concatenate.;None $*,-/69:;<=?ABCDMOQRTb Produce a Stream% for the elements of the given array.Compute the elements of a pure Stream#, writing them into a new array E.Compute the elements of an < Stream, writing them to a new E.*None $*,-/69:;<=?ABCDMOQRTbCombination of fold and =. }We walk over the stream front to back, maintaining an accumulator. At each point we can chose to emit an element (or not).Like r but use the first value of the stream as the initial state, and add the final state to the end of the output.+None $*,-/69:;<=?ABCDMOQRTb#Merge two sorted key-value streams.Like E, but only produce the elements where the worker functions return >.Name of destination layout.%Combine two values with the same key.*Handle a left value without a right value.*Handle a right value without a left value.Array of keys and left values.Array of keys and right values.Array of keys and results.%Combine two values with the same key.*Handle a left value without a right value.*Handle a right value without a left value.Array of keys and left values.Array of keys and right values.Array of keys and results.,None $*,-/69:;<=?ABCDMOQRTbSegmented replicate.None $*,-/69:;<=?ABCDMOQRTbA delayed array formed from two source arrays. The source arrays can have different layouts but must have the same extent.,Wrap two existing arrays in a delayed array.@Combine two arrays element-wise using the given worker function.6The two source arrays must have the same extent, else .Delayed arrays.Delayed arrays. ?@ABE?A?B@None $*,-/69:;<=?ABCDMOQRTb[The Dense layout maps a higher-ranked index space to some underlying linear index space.oFor example, we can create a dense 2D row-wise array where the elements are stored in a flat unboxed vector: > import Data.Repa.Array.Material > let Just arr = fromListInto (matrix U 10 10) [1000..1099 :: Float] > :type arr arr :: Array (E U (RW DIM2) Float > arr ! (Z :. 5 :. 4) > 1054.0 6Yield a layout for a dense vector of the given length.\The first argument is the name of the underlying linear layout which stores the elements.IYield a layout for a matrix with the given number of rows and columns.PYield a layout for a cube with the given number of planes, rows, and columns.Dense buffers. Dense arrays. Dense arrays.CDEFGH<EEDCFCGDHENone $*,-/69:;<=?ABCDMOQRTbYTupled arrays where the components are unpacked and can have separate representations.(Tuple two arrays into an array of pairs.The two argument arrays must have the same index type, but can have different extents. The extent of the result is the intersection of the extents of the two argument arrays. 3Untuple an array of tuples in to a tuple of arrays.The two returned components may have different extents, though they are guaranteed to be at least as big as the argument array. This is the key property that makes   different from unzip. Tupled buffers. Tupled windows. Tupled arrays.IJK L  M N <KEJI    LI  MJ NK-None $*,-/69:;<=?ABCDMOQRTb>Insert elements produced by the given function in to an array.Name of destination layout."Produce an element for this index.Array of source elements..None $*,-/69:;<=?ABCDMOQRTb4Left fold of all elements in an array, sequentially.*Yield the sum of the elements of an array..Yield the product of the elements of an array.1Yield the mean value of the elements of an array.8Yield the standard deviation of the elements of an array.Compute the Pearson correlation of two arrays.LIf the arrays differ in length then only the common prefix is correlated.None $*,-/69:;<=?ABCDMOQRTb Produce a O for the elements of the given array. The order in which the elements appear in the chain is determined by the layout of the array.P%Lift a pure chain to a monadic chain.Compute the elements of a pure O#, writing them into a new array E.Compute the elements of an < O, writing them to a new E.PP/None $*,-/69:;<=?ABCDMOQRTb.Dictionaries need to perform a segmented fold.@Segmented fold over vectors of segment lengths and input values.lThe total lengths of all segments need not match the length of the input elements vector. The returned  state can be inspected to determine whether all segments were completely folded, or the vector of segment lengths or elements was too short relative to the other. > import Data.Repa.Array.Material > import Data.Repa.Nice > let segs = fromList B [("red", 3), ("green", 5)] > let vals = fromList U [0..100 :: Int] > nice $ fst $ folds B U (+) 0 segs vals [("red",3),("green",25)] Like 2, but take an initial state for the first segment. > import Data.Repa.Array.Material > import Data.Repa.Nice > let state = Just ("white", 4, 100) > let segs = fromList B [("red", 3), ("green", 5)] > let vals = fromList U [0..100 :: Int] > nice $ fst $ foldsWith B U (+) 0 state segs vals [("white",106),("red",15),("green",45)] Layout for group names.Layout for fold results.Worker function.$Initial state when folding segments.Segment names and lengths. Elements.Layout for group names.Layout for fold results.Worker function.$Initial state when folding segments.1Name, length and initial state for first segment.Segment names and lengths. Elements. 0None $*,-/69:;<=?ABCDMOQRTb (Dictionaries need to perform a grouping.!xFrom a stream of values which has consecutive runs of idential values, produce a stream of the lengths of these runs. j> import Data.Repa.Array.Material > import Data.Repa.Nice > nice $ groups U U (fromList U "waaabllle") ([(w,1),(a,3),(b,1),(l ,3)],Just (e,1)) "Like !, but use the given function to determine whether two consecutive elements should be in the same group. Also take an initial starting group and count. ^> import Data.Repa.Array.Material > import Data.Repa.Nice > nice $ groupsWith U U (==) (Just (w", 5)) (fromList U "waaabllle") ([(w,6),(a,3),(b,1),(l ,3)],Just (e,1))  !Layout for group names.Layout gor group lengths.Input elements."Layout for group names.Layout for group lengths.Comparison function.Starting element and count.Input elements. !" !"1None $*,-/69:;<=?ABCDMOQRTb#+Apply a generic stream process to an array.$+Apply a generic stream process to an array.#Name of destination layout.Worker function.Initial state. Input array.Result state and array.$Name of destination layout.Worker function.Initial state. Input array.Result state and array. #$#$2None $*,-/69:;<=?ABCDMOQRTb)Z[\]^_`abcdlmno{|}~ )lmno{|}~\]^_`Z[abcd None $*,-/69:;<=?ABCDMOQRTb%cNested array represented as a flat array of elements, and a segment descriptor that describes how the elements are partitioned into the sub-arrays. Using this representation for multidimentional arrays is significantly more efficient than using a boxed array of arrays, as there is no need to allocate the sub-arrays individually in the heap.With a nested type like: Array N (Array N (Array U Int)), the concrete representation consists of five flat unboxed vectors: two for each of the segment descriptors associated with each level of nesting, and one unboxed vector to hold all the integer elements.|UNSAFE: Indexing into raw material arrays is not bounds checked. You may want to wrap this with a Checked layout as well.QSegment start positions.RSegment lengths.SElement values.(1O(size src) Convert some lists to a nested array.)BO(size src) Convert a triply nested list to a triply nested array.*cApply a function to all the elements of a doubly nested array, preserving the nesting structure.+JO(1). Produce a nested array by taking slices from some array of elements.This is a constant time operation, as the representation for nested vectors just wraps the starts, lengths and elements vectors.,_Segmented concatenation. Concatenate triply nested vector, producing a doubly nested vector.Unlike the plain T function, this operation is performed entirely on the segment descriptors of the nested arrays, and does not require the inner array elements to be copied. > import Data.Repa.Nice > nice $ concats $ fromListss U [["red", "green", "blue"], ["grey", "white"], [], ["black"]] ["red","green","blue","grey","white","black"] -zO(len src). Given predicates which detect the start and end of a segment, split an vector into the indicated segments..EO(len src). Given a terminating value, split an vector into segments.2The result segments do not include the terminator. > import Data.Repa.Nice > nice $ segmentOn (== ' ') (fromList U "fresh fried fish ") ["fresh "," "," ","fried ","fish "," "] /O(len src). Like -!, but cut the source array twice.0\O(len src). Given field and row terminating values, split an array into rows and fields.1yFor each segment of a nested array, trim elements off the start and end of the segment that match the given predicate.2pFor each segment of a nested array, trim elements off the end of the segment that match the given predicate.3qFor each segment of a nested array, trim elements off the start of the segment that match the given predicate.4*Ragged transpose of a triply nested array.This operation is performed entirely on the segment descriptors of the nested arrays, and does not require the inner array elements to be copied.5Windowing Nested arrays.7Nested arrays.8Nested arrays.%&'UVQRSW()*+Segment starting positions.Segment lengths.Array elements.,-Detect the start of a segment.Detect the end of a segment.Vector to segment..Detect the end of a segment.Vector to segment./%Detect the start of an inner segment.%Detect the end of an inner segment.%Detect the start of an outer segment.%Detect the end of an outer segment.Array to dice.0'Terminating element for inner segments.'Terminating element for outer segments.Vector to dice.12345X6Y7Z8 <W07E6$/VQRS%&'()*+,-./01234%&' ()*+,-./01234%&'()*+,-./0123456XU7YVQRS8ZW3None $*,-/69:;<=?ABCDMOQRTb>Take a desired number of segments, and array of key value pairs where the key is the segment number. Partition the values into the stated number of segments, discarding values where the key falls outside the given range.This function operates by first allocating a buffer of size (segs * len src) and filling it with a default value. Both the worst case runtime and memory use will be poor for a large number of destination segments. TODO: we need the pre-init because otherwise unused values in the elems array are undefined. We could avoid this by copying out the used elements after the partition loop finishes. Use a segmented extract function. This would also remove the dependency on the [ class.?Like >R but use the provided function to compute the segment number for each element. @Like > but use the provided function to compute the segment number for each element. The function is given the index of the each element, along with the element itself.>Name of destination layout.Total number of segments.Segment numbers and values. Result array?Name of destination layout.Total number of Segments.(Get the segment number for this element.Source values.@Name of destination layout.Total number of Segments.(Get the segment number for this element.Source values.>?@>?@None $*,-/69:;<=?ABCDMOQRTb<0E$/. None $*,-/69:;<=?ABCDMOQRTbAGiven a buffer containing an encoded table where the values in each column all have the same time, decode all the values from a single column and write them to a buffer.For example, suppose we have a table as follows, where the rows are separated by newline characters and the field separated by spaces. DRED 1.0 0.0 0.0 GREEN 0.0 1.0 0.0 BLUE 0.0 0.0 1.0 CYAN 0.0 1.0 1.0  To decode the second column use:/Format: DoubleAsc, as they are encoded doubles.;Field separator: ' ' as the fields are separated by spaces.{Starting offsets: [3, 21, 38, 55], which are the indices of the starting character of each field in the second column.WEnding offsets: [16, 34, 51, 68], which are the indices of the newline characters.kDestination buffer: an new buffer with at least as many elements as there are lines in the input data.If the parse succeeds then the buffer containing the starting offets is updated so each element is the index of the NEXT field in each column. This allows the client to easilly decode the next column.If there was a parse error then this function returns a pair of the row index and offset in the buffer of the field which could not be parsed.UNSAFE: Both the buffer containing ending offsets, and the destination buffer must be at least as long as the buffer containing starting offsets but this is not checked. If this is not true then the function will will perform an out of bounds access.INLINE: This function is set to INLINE so that it will be specialised at the call site for the given format. For standard formats it's better to use the pre-specialised versions for Auto arrays.AFormat for each element.Field separator character.Packed binary source data.Starting offsets for fields.Ending offsets of rows.%Destination buffer for parsed fields.Nothing on successful parse.AAA4None $*,-/69:;<=?ABCDMOQRTbBiArrays where the elements that are automatically layed out into some efficient runtime representation.GThe implementation uses type families to chose unboxed representations for all elements that can be unboxed. In particular: arrays of unboxed tuples are represented as tuples of unboxed arrays, and nested arrays are represented using a segment descriptor and a single single flat vector containing all the elements.BCD\]^< W\07KE6$/JVQRSBCDBCD^]\5None $*,-/69:;<=?ABCDMOQRTb_`abcdefE`_acb_dfe`6None $*,-/69:;<=?ABCDMOQRTbghijklmn< W\07KE6$/JVhQRSBCDikjglnmh7None $*,-/69:;<=?ABCDMOQRTbopqrstuv< W\07KE6$/JVpQRSBCDqsrotvup8None $*,-/69:;<=?ABCDMOQRTbwxyz{|}~< W\07KE6$/JVxQRSBCDy{zw|~}x9None $*,-/69:;<=?ABCDMOQRTbESafe $*,-/69:;<=?ABCDMOQRTbE@Constant time conversion of one array representation to another.EFGEFEFEFG:None $*,-/69:;<=?ABCDMOQRTb E;None $*,-/69:;<=?ABCDMOQRTbE <None $*,-/69:;<=?ABCDMOQRTb- E=None $*,-/69:;<=?ABCDMOQRTb E>None $*,-/69:;<=?ABCDMOQRTb E?None $*,-/69:;<=?ABCDMOQRTb ENone $*,-/69:;<=?ABCDMOQRTbHO(len src) Yield >= the index of the first element matching the predicate or  if no such element exists.ILike , but immediately  the result.JLike , but immediately  the result.KFO(1). Constant time conversion of one array representation to another.L>O(n). Linear time copy of one array representation to another.&This function must be used instead of KM when the bit-wise layout of the two array representations are different.HIName of destination layout.Worker function. Source array.JName of destination layout.Worker function. Source array. Source arrayKLC <CDEGFHIJKL !"#$HIJKLBDEFGCHIJKLKLIJ#$ H!" HIJKL@None $*,-/69:;<=?ABCDMOQRTbpGiven a row ending byte and a buffer containing encoded rows, get buffers of row starting and ending indices.ANone $*,-/69:;<=?ABCDMOQRTbMHYield an array containing a range of dates, inclusive of the end points.MMMNone $*,-/69:;<=?ABCDMOQRTbN"Convert some value to a nice form.In particular:kNested Arrays are converted to nested lists, so that they are easier to work with on the ghci console.)Lists of characters are wrapped into the SX data type, so that they can be pretty printed differently by follow-on processing.1As ghci automatically pretty prints lists, using nice is more fun than trying to show$ the raw Repa array representations.QaWrapper to indicate a list of characters should be printed as a string, without double quotes.ScWrapper to indicate a list of characters should be printed as a string, including double quotes.-NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzNOPQRSTNOPSTQR)NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzNone $*,-/69:;<=?ABCDMOQRTb {5Convert some value to a form presentable to the user.Like ` but we allow the nesting structure to be preserved so it can be displayed in tabular format.}A value, wrapped up nicely.~Nothing to present.An atomic thing.6Many of the same thing, to display with list brackets  [.. , ..]7Some different things, to display with tuple brackets  (.. , ..)Yield the nesting depth of a }/Strip the top two layers of nesting into lists.+Strip the top layer of nesting into a list.Flatten a present into text{|}~QRST{|}~{|}~STQR{|}~None $*,-/69:;<=?ABCDMOQRTb4Print a nested value to the console in tabular form.The first two layers of nesting are displayed as rows and columns. Numeric data is right-justified, while the rest is left-justified. ^> tab [[10, 20, 302], [40, 50], [60, 7001, 80, 90 :: Int]] 10 20 302 40 50 60 7001 80 90 5Deeper layers of nesting are preserved in the output: k> tab [[[10], [20, 21]], [[30, 31], [40, 41, 41], [50 :: Int]]] [10] [20,21] [30,31] [40,41,41] [50] 7By default, strings are printed as lists of characters: > tab [[("red", 10), ("green", 20), ("blue", 30)], [("grey", 40), ("white", 50 :: Int)]] (['r','e','d'],10) (['g','r','e','e','n'],20) (['b','l','u','e'],30) (['g','r','e','y'],40) (['w','h','i','t','e'],50) 7If you want double-quotes then wrap the strings with a Str constructor: > tab [[(Str "red", 10), (Str "green", 20), (Str "blue", 30)], [(Str "grey", 40), (Str "white", 50 :: Int)]] ("red",10) ("green",20) ("blue",30) ("grey",40) ("white",50) 3If you don't want any quotes then wrap them with a Tok constructor: > tab [[(Tok "red", 10), (Tok "green", 20), (Tok "blue", 30)], [(Tok "grey", 40), (Tok "white", 50 :: Int)]] (red,10) (green,20) (blue,30) (grey,40) (white,50) 'Display a nested value in tabular form.QRSTSTQRBNone $*,-/69:;<=?ABCDMOQRTb1Form the product of two arrays, in constant time.1Unpack a product of two arrays, in constant time. E None $*,-/69:;<=?ABCDMOQRTb6< W\07KE6$/JV`hpxQRS_BCDMBCDMNone $*,-/69:;<=?ABCDMOQRTb2Classes supported by all material representations.}We can index them in a random-access manner, window them in constant time, and use them as targets for a computation.eIn particular, delayed arrays are not material as we cannot use them as targets for a computation.O < W\07KE6$/JV`hpxQRS%&'()*+,-./01234>?@BCD,BCD%&'() *+>?@,-./01234CNone $*,-/69:;<=?ABCDMOQRTb jUnpack an encoded table of values from an array of bytes, and write the result into an existing buffer.<The implementation invokes specialised code for each format.     !"#      !"#DNone $*,-/69:;<=?ABCDMOQRTbZClass of elements where arrays of those elements can be constructed in arbitrary order.BClass of elements that can be automatically organised into arrays.bArrays of elements that are automatically layed out into some efficient runtime representation.GThe implementation uses type families to chose unboxed representations for all elements that can be unboxed. In particular: arrays of unboxed tuples are represented as tuples of unboxed arrays, and nested arrays are represented using a segment descriptor and a single single flat vector containing all the elements.ENone $*,-/69:;<=?ABCDMOQRTb<$O(1). Get an element from an array. bIf the provided index is outside the extent of the array then the result depends on the layout.O(1). Alias for -O(1). Get the number of elements in an array.-O(1). Take the first element of an array, or  if it's empty.,O(1). Take the last element of an array, or  if it's empty.O(1). alias for .$O(1). Take the tail of an array, or  if it's empty.0O(1). Take the initial elements of an array, or  if it's empty.)O(1). An empty array of the given layout.;O(1). Create a new empty array containing a single element.Like  generateSN but use a function that produces Maybe an element. If any element returns , then  for the whole array.NApply a function to every element of an array, if any application returns , then  for the whole result.Like  generateS] but use a function that produces Either some error or an element. If any element returns , then  for the whole array.NApply a function to every element of an array, if any application returns , then  for the whole result.Convert a list to an array."Convert a nested list to an array.6Convert a triply nested list to a triply nested array.Convert an array to a list.%Convert a nested array to some lists.6Convert a triply nested array to a triply nested list.%O(n). Reverse the elements of a list. H> toList $ reverse $ fromList [0 .. 10 :: Int] [10,9,8,7,6,5,4,3,2,1,0] Segmented replicate./Apply a function to all the elements of a list.3Combine two arrays of the same length element-wise..If the arrays don't have the same length then .dApply a function to all the elements of a doubly nested array, preserving the nesting structure. This function has a non-standard time complexity. As nested arrays use a segment descriptor based representation, detatching and reattaching the nesting structure is a constant time operation. However, the array passed to the worker function will also contain any elements in the array representation that are not reachable from the segment descriptor. This matters if the source array was produced by a function that filters the segments directly, like .&Left fold of all elements in an array.*Yield the sum of the elements of an array..Yield the product of the elements of an array.1Yield the mean value of the elements of an array.8Yield the standard deviation of the elements of an array.Compute the Pearson correlation of two arrays.LIf the arrays differ in length then only the common prefix is correlated.@Segmented fold over vectors of segment lengths and input values.lThe total lengths of all segments need not match the length of the input elements vector. The returned  state can be inspected to determine whether all segments were completely folded, or the vector of segment lengths or elements was too short relative to the other.Like 2, but take an initial state for the first segment.HO(len src) Keep the elements of an array that match the given predicate.JO(1). Produce a nested array by taking slices from some array of elements.This is a constant time operation, as the representation for nested vectors just wraps the starts, lengths and elements vectors.zFor each segment of a nested vector, trim elements off the start and end of the segment that match the given predicate.pFor each segment of a nested array, trim elements off the end of the segment that match the given predicate.qFor each segment of a nested array, trim elements off the start of the segment that match the given predicate.1O(1). Pack a pair of arrays to an array of pairs.3O(1). Unpack an array of pairs to a pair of arrays.Concatenate nested arrays.O(len result) Concatenate the elements of some nested vector, inserting a copy of the provided separator array between each element.fO(len result) Concatenate the outer two layers of a triply nested array. (Segmented concatenation).The operation is performed entirely on the segment descriptors of the array, and does not require the inner array elements to be copied."This version is faster than plain  on triply nested arrays.O(len result) Perform a ?, adding a newline character to the end of each inner array.tO(len result) Insert a copy of the separator array between the elements of the second and concatenate the result.*Ragged transpose of a triply nested array.This operation is performed entirely on the segment descriptors of the nested arrays, and does not require the inner array elements to be copied.CTake a slice out of an array, given a starting position and length.#Merge two sorted key-value streams.Like E, but only produce the elements where the worker functions return >.Combination of fold and . |We walk over the stream front to back, maintaining an accumulator. At each point we can chose to emit an element (or not)Like r but use the first value of the stream as the initial state, and add the final state to the end of the output.+Apply a generic stream process to an array.>Insert elements produced by the given function in to an array.O(len src) Yield >= the index of the first element matching the predicate or  if no such element exists.zO(len src). Given predicates which detect the start and end of a segment, split an vector into the indicated segments.EO(len src). Given a terminating value, split an vector into segments.2The result segments do not include the terminator.O(len src). Like !, but cut the source array twice.\O(len src). Given field and row terminating values, split an array into rows and fields.xFrom a stream of values which has consecutive runs of idential values, produce a stream of the lengths of these runs.Like , but use the given function to determine whether two consecutive elements should be in the same group. Also take an initial starting group and count.<Worker function.$Initial state when folding segments.Segment names and lengths. Elements.Worker function.$Initial state when folding segments.1Name, length and initial state for first segment.Segment names and lengths. Elements.Segment starting positions.Segment lengths.Array elements.Arrays to concatenate.Separator array.Arrays to concatenate.Separator array.Arrays to concatenate.%Combine two values with the same key.*Handle a left value without a right value.*Handle a right value without a left value.Array of keys and left values.Array of keys and right values.Array of keys and results.%Combine two values with the same key.*Handle a left value without a right value.*Handle a right value without a left value.Array of keys and left values.Array of keys and right values.Array of keys and results.Worker functionInitial state. Input array.Result state and array.Detect the start of a segment.Detect the end of a segment.Array to segment.Detect the end of a segment.Array to segment.%Detect the start of an inner segment.%Detect the end of an inner segment.%Detect the start of an outer segment.%Detect the end of an outer segment.Array to dice.'Terminating element for inner segments.'Terminating element for outer segments.Vector to dice.Input elements.$Completed and final segment lengths.Comparison function.Starting element and count.Input elements.$Completed and final segment lengths.?<None $*,-/69:;<=?ABCDMOQRTb)Read an entire file as an array of bytes."Write an array of bytes to a file.#Append an array of bytes to a file.=Get data from a file handle, up to the given number of bytes.|Get data from a file handle, up to the given number of bytes, also copying the given data to the front of the new buffer.Write data into a file.None $*,-/69:;<=?ABCDMOQRTbPRead a XSV file as a nested array. We get an array of rows:fields:characters.QRead an XSV file as a nested array. We get an array of rows:fields:characters.$Write a nested array as an XSV file.*The array contains rows:fields:characters.$Write a nested array as an XSV file.*The array contains rows:fields:characters.Field separator character, eg '|' , ',' or '\t'.Source file handle.Field separator character, eg '|' , ',' or '\t'.Source file handle.Separator character, eg '|' , ',' or '\t'Source file handle.Array of row, field, character.Separator character, eg '|' , ',' or '\t'Source file handle.Array of row, field, character. None $*,-/69:;<=?ABCDMOQRTbTry to read an $# from the given offset in an array.rIf the conversion succeeded then you get the value, along with the index of the next character, otherwise .Unboxed version of .WWe still pay to unbox the input array, but avoid boxing the result by construction.3Convert a foreign vector of characters to a Double.The standard Haskell %D type is four bytes in length. If you already have a vector of & then use & instead to avoid the conversion..Convert a foreign vector of bytes to a Double. Convert a '% to ASCII text packed into a foreign Vector. Convert a '% to ASCII text packed into a foreign Vector.Like >, but use a fixed number of digits after the decimal point.Like >, but use a fixed number of digits after the decimal point. ( (None $*,-/69:;<=?ABCDMOQRTb8Dictionaries needed to unpack a row of the given format.2Pack a value into a buffer using the given format.=Pack an array of values into a buffer using the given format.NThe bytes representing each value are concatenated together with no delimitor.Like ?, but append a newline character after every packed element.?If a value cannot be converted then this function just returns ).4Unpack a value from a buffer using the given format.9Unpack an encoded table of values from an array of bytes.Format for the value. Source value.Packed binary data.Format for each valueSource values.Packed binary data.Format for each valueSource values.Packed binary data.Format for the value.Packed binary data.Unpacked value.Format of each row. Source data.Array of rows.d*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None $*,-/69:;<=?ABCDMOQRTbIIFNone $*,-/69:;<=?ABCDMOQRTbFFGHIGHJGHKGHLGHMGHNGHNGOPGOQGORGOSGOTUVWXYZ[[\]^_`abcdefg!h!i!j!k!l!m!n!n!o!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!"""""""""##########        %%%%%%%%%%%%%%%%%%%%&&& '         ((((( ( ( ( ( ())))) !*"*#+$+%,&'()*+,-./0123456789:;<=>?@ABCDE-F.G.H.I.J.K.LMNO/P/Q/R0S0T0U1V1WXYZ[\]^_`abcdefghijklm3n3o3pq4r4s4tuvwxyzv{A|}~BBBBBBBBBBCDDDEEEEEEEEEEEEEEEE[E\EEEEE&EE,E]EGEHEIEJEKELEQEREE^EdEeEfEEEEE_EEEgEE$E%E"E#EVEFExE`EaEbEcETEU        !!!##$$$$$$$$$       %          ((( (!("(#((($(%(&'()*+),-./012'34526789:<;<=G>?@ABCDEFXGHIJKL4r4M4N5O5P55Q5R5S5T5U6V6W66X6Y6Z6[6\7]7^77_7`7a7b7c8d8e88f8g8h8i8j9k9l9m9n9o9p9q:r:s::t:u:v:w:x:y:z;{;|;};~;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<==========>>>>>>>>>???????????@AAAAAAABBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCC C C C C -.-.-.   !"#$%$&$'()()(*(*(+(+(,(,-.-/-0-1-2-345454646787879797:7:7;7;<=<=<><>?@?@ABABACACADADAEAEAFAFAGAGAHAHAIAIAJAJAKAKLMLMNONPNQNRNfNSTXTUTVTWTXTYZ[Z\Z\Z]^_^`^`^abcdbcde)repa-array-4.2.3.1-JSRUbbBMJ9D7tiw14S3wN5Data.Repa.Array.Generic Data.Repa.Array.Material.UnboxedData.Repa.Nice.DisplayData.Repa.Fusion.UnpackData.Repa.Array.Generic.IndexData.Repa.Array.Generic.SliceData.Repa.Array.Meta.WindowData.Repa.Array.Meta.LinearData.Repa.Array.Meta.RowWiseData.Repa.Array.Generic.TargetData.Repa.Array.Generic.LoadData.Repa.Array.Material.BoxedData.Repa.Array.Meta.Delayed Data.Repa.Array.Material.ForeignData.Repa.Eval.StreamData.Repa.Array.Meta.Delayed2Data.Repa.Array.Meta.DenseData.Repa.Array.Meta.TupleData.Repa.Eval.ChainData.Repa.Array.Material.NestedData.Repa.Array.MaterialData.Repa.Array.Generic.UnpacksData.Repa.Array.Material.AutoData.Repa.Array.Generic.ConvertData.Repa.NiceData.Repa.Nice.PresentData.Repa.Nice.TabulateData.Repa.Array.AutoData.Repa.Array.Auto.FormatData.Repa.Array.Auto.IOData.Repa.Array.Auto.XSVData.Repa.Array.Auto.ConvertData.Repa.Array.Internals.Shape Data.Repa.Array.Internals.LayoutData.Repa.Array.Internals.BulkData.Repa.Array.Internals.Check Data.Repa.Array.Internals.TargetData.Repa.Array.Internals.Load)Data.Repa.Array.Internals.Operator.Filter%Data.Repa.Array.Material.Foreign.Base)Data.Repa.Array.Internals.Operator.Concat*Data.Repa.Array.Internals.Operator.Compact(Data.Repa.Array.Internals.Operator.Merge,Data.Repa.Array.Internals.Operator.Replicate)Data.Repa.Array.Internals.Operator.Insert)Data.Repa.Array.Internals.Operator.Reduce'Data.Repa.Array.Internals.Operator.Fold(Data.Repa.Array.Internals.Operator.Group*Data.Repa.Array.Internals.Operator.ProcessData.Repa.Array.Meta,Data.Repa.Array.Internals.Operator.Partition"Data.Repa.Array.Material.Auto.Base%Data.Repa.Array.Material.Auto.InstBox&Data.Repa.Array.Material.Auto.InstList'Data.Repa.Array.Material.Auto.InstMaybe&Data.Repa.Array.Material.Auto.InstText&Data.Repa.Array.Material.Auto.InstUnit&Data.Repa.Array.Material.Auto.InstChar'Data.Repa.Array.Material.Auto.InstFloat%Data.Repa.Array.Material.Auto.InstInt'Data.Repa.Array.Material.Auto.InstTuple&Data.Repa.Array.Material.Auto.InstWord'Data.Repa.Array.Material.Auto.InstArray,Data.Repa.Array.Material.Auto.Operator.Lines(Data.Repa.Array.Material.Auto.InstDate32)Data.Repa.Array.Material.Auto.InstProduct2Data.Repa.Array.Material.Auto.Operator.UnpackablesData.Repa.Array.Auto.BaseData.Repa.Array.Auto.OperatorData.Repa.Array*repa-stream-4.2.3.1-KH9vCME1jP07YpNM5gG9FEData.Repa.Chain.Folds_valSeg_lenSeg_nameSeg _stateVals _stateLensFoldsData.Repa.Chain.ScanStepUnfoldFinishStepUnfoldBumpStepUnfoldNextStepUnfoldGive StepUnfold'vector-0.10.12.3-IR1PdKtcTMfG5IvQmU7vVFData.Vector.Unboxed.BaseUnboxFormat FormatNumeric FormatTextDisplaydisplay takeDisplaypadLpadR$fMonoidDisplay $fEqFormat $fShowFormat $fEqDisplay $fShowDisplayUnpackunpackrepackSH5SH4SH3SH2SH1SH0:.ZShaperankzeroDimunitDim intersectDimaddDimsize inShapeRange listOfShape shapeOfListinShape showShapeish0ish1ish2ish3ish4ish5LayoutILayoutNameIndexnamecreateextenttoIndex fromIndexBulkIBulkArraylayoutindex!lengthfirstlasttoListSlice sliceOfFull fullOfSlice SliceShape FullShapeAnyAll $fSlice:. $fSlice:.0 $fSliceAny$fSliceZ WindowablewindowWWindow windowStart windowSize windowInnerwindowedentiretailinit$fWindowableWa$fBulkWa $fLayoutW $fShowName$fEqName$fEqW$fShowWLLinear linearLengthlinear $fBulkLInt $fLayoutL$fShowL$fEqLDIM5DIM4DIM3DIM2DIM1RWRowWise rowWiseShaperowWiseix1ix2ix3ix4ix5 $fBulkRWsh $fLayoutRW $fLayoutRW0 $fShapeRW $fShowName0 $fEqName0$fShowRW$fEqRWTargetITargetBufferunsafeNewBufferunsafeReadBufferunsafeWriteBufferunsafeGrowBufferunsafeSliceBufferunsafeFreezeBufferunsafeThawBuffer touchBuffer bufferLayoutempty singletonfromList fromListInto mapMaybeS mapEitherSgenerateMaybeSgenerateEitherSLoadloadSloadPcomputeS computeIntoSfilterBBoxed boxedLength fromBoxedtoBoxeddecimate $fTargetBa$fWindowableBa $fEqArray$fBulkBa $fLayoutB$fShowB$fEqB $fShowArrayDDelayed delayedLayout fromFunction toFunctiondelaymapreverse $fLoadDl2a$fBulkDa $fLayoutD$fShowD$fEqDFForeign foreignLength unsafeCastfromForeignPtr toForeignPtrtoStorableVectorfromStorableVector toByteStringfromByteStringUUnboxed unboxedLength fromUnboxed toUnboxed $fTargetUa$fWindowableUa$fBulkUa $fLayoutU$fShowU$fEqU ConcatDictconcat concatWithunlines intercalate streamOfArrayunstreamToArrayunstreamToArrayIOcompact compactInmerge mergeMaybe replicatesD2Delayed2delayed2Layout1delayed2Layout2delay2map2 $fLoadD2lDsta $fBulkD2a $fLayoutD2$fShowD2$fEqD2EDensevectormatrixcube $fTargetEa$fBulkEa $fLayoutE$fShowE$fEqET2Tup2tup2untup2 $fTargetT2(,)$fWindowableT2(,) $fBulkT2(,) $fLayoutT2$fShowT2$fEqT2insertfoldlsumproductmeanstd correlate chainOfArrayunchainToArrayunchainToArrayIO FoldsDictfolds foldsWith GroupsDictgroups groupsWithprocessunfoldsNNested nestedLength fromLists fromListssmapElemsslicesconcatssegment segmentOndicediceSeptrimstrimEnds trimStarts ragspose3$fWindowableNArray$fTargetNArray $fBulkNArray $fLayoutN$fShowN$fEqN partition partitionBy partitionByIxunsafeUnpacksToBufferAAuto autoLengthConvertconvert $fConvertrara findIndexmapSmap2Scopy rangeDate32NicerNiceniceTokStr $fNicer[] $fNicer[]0 $fNicer[]1 $fNicer[]2 $fNicer[]3 $fNicerArray $fNicer:*: $fNicer(,) $fNicerMaybe $fNicer[]4 $fNicer[]5 $fNicer[]6 $fNicer[]7 $fNicer[]8 $fNicer[]9 $fNicer[]10 $fNicer[]11 $fNicer[]12 $fNicer[]13 $fNicer[]14 $fNicer[]15 $fNicerDate32 $fNicerWord64 $fNicerWord32 $fNicerWord16 $fNicerWord8 $fNicerWord $fNicerInt64 $fNicerInt32 $fNicerInt16 $fNicerInt8 $fNicerInt $fNicerDouble $fNicerFloat $fNicerChar $fNicer() $fShowTok $fShowStr PresentablepresentPresentBlankAtomManySomedepthstrip2strip1flatten$fPresentable(,,,,)$fPresentable(,,,)$fPresentable(,,)$fPresentable(,)$fPresentable:*:$fPresentable[]$fPresentableTok$fPresentableStr$fPresentableDate32$fPresentableWord64$fPresentableWord32$fPresentableWord16$fPresentableWord8$fPresentableDouble$fPresentableFloat$fPresentableInt$fPresentableChar$fPresentable() $fEqPresent $fShowPresenttabtabulateProd9Prod8Prod7Prod6Prod5Prod4Prod3Prod2produnprodMaterial UnpackablesBuildElemheadtoListstoListsszipunzipslicereadFile writeFile appendFile hGetArray hGetArrayPre hPutArraygetArrayFromXSVhGetArrayFromXSV putArrayAsXSVhPutArrayAsXSVreadIntFromOffsetreadIntFromOffset# readDoublereadDoubleFromBytes showDoubleshowDoubleAsBytesshowDoubleFixedshowDoubleFixedAsBytes UnpackableRow packFormat packsFormat packsFormatLn unpackFormatunpacksFormatLn $fShape:.$fShapeZ $fShapeIntbaseGHC.BaseNothingWArray D:R:ArrayWa0 D:R:NameW0LArrayD:R:ArrayLInt0 D:R:NameL0UnsafeSafeCheckmethodcheck $fCheckUnsafe $fCheckSafeRArrayRCRZD:R:ArrayRWsh0 D:R:NameRW0 D:R:NameRW2 Data.EitherLeftunfoldEitherOfLengthIOBBufferBArray D:R:BufferBa0 D:R:ArrayBa0 D:R:NameB0ADelayed D:R:ArrayDa0 D:R:NameD0GHC.ForeignPtr ForeignPtrbytestring-0.10.8.1Data.ByteString.Internal ByteString $fTargetFa$fWindowableFa$fBulkFa $fLayoutFFBufferFArray D:R:BufferFa0 D:R:ArrayFa0 D:R:NameF0UBufferUArray D:R:BufferUa0 D:R:ArrayUa0 D:R:NameU0 loop_concatghc-prim GHC.TypesIOGHC.ListJust ADelayed2 D:R:ArrayD2a0 D:R:NameD20EBuffer D:R:BufferEa0 D:R:ArrayEa0 D:R:NameE0T2BufferT2ArrayD:R:BufferT2(,)0D:R:ArrayT2(,)0 D:R:NameT20Data.Repa.Chain.BaseChain liftChain nArrayStarts nArrayLengths nArrayElems Data.FoldableNBufferNArrayD:R:BufferNArray0D:R:ArrayNArray0 D:R:NameN0(repa-eval-4.2.3.1-2mCiPNA5v7JAi4NoRpXJjMData.Repa.Eval.EltElt D:R:NameA0 $fLayoutA ABuffer_Box AArray_BoxD:R:BufferABox0 $fTargetABox$fWindowableABoxD:R:ArrayABox0 $fBulkABox ABuffer_List AArray_ListD:R:BufferA[]0 $fTargetA[]$fWindowableA[] D:R:ArrayA[]0 $fBulkA[] ABuffer_Maybe AArray_MaybeD:R:BufferAMaybe0$fTargetAMaybe$fWindowableAMaybeD:R:ArrayAMaybe0 $fBulkAMaybe ABuffer_Text AArray_TextD:R:BufferAText0 $fTargetAText$fWindowableATextD:R:ArrayAText0 $fBulkAText ABuffer_Unit AArray_UnitD:R:BufferA()0 $fTargetA()$fWindowableA() D:R:ArrayA()0 $fBulkA() ABuffer_Char AArray_CharD:R:BufferAChar0 $fTargetAChar$fWindowableAChar$fConvertACharFChar$fConvertFCharACharD:R:ArrayAChar0 $fBulkACharABuffer_Double AArray_Double ABuffer_Float AArray_FloatD:R:BufferADouble0$fTargetADouble$fWindowableADouble$fConvertADoubleFDouble$fConvertFDoubleADoubleD:R:ArrayADouble0 $fBulkADoubleD:R:BufferAFloat0$fTargetAFloat$fWindowableAFloat$fConvertAFloatFFloat$fConvertFFloatAFloatD:R:ArrayAFloat0 $fBulkAFloat ABuffer_Int64 AArray_Int64 ABuffer_Int32 AArray_Int32 ABuffer_Int16 AArray_Int16 ABuffer_Int8 AArray_Int8 ABuffer_Int AArray_IntD:R:BufferAInt640$fTargetAInt64$fWindowableAInt64$fConvertAInt64FInt64$fConvertFInt64AInt64D:R:ArrayAInt640 $fBulkAInt64D:R:BufferAInt320$fTargetAInt32$fWindowableAInt32$fConvertAInt32FInt32$fConvertFInt32AInt32D:R:ArrayAInt320 $fBulkAInt32D:R:BufferAInt160$fTargetAInt16$fWindowableAInt16$fConvertAInt16FInt16$fConvertFInt16AInt16D:R:ArrayAInt160 $fBulkAInt16D:R:BufferAInt80 $fTargetAInt8$fWindowableAInt8$fConvertAInt8FInt8$fConvertFInt8AInt8D:R:ArrayAInt80 $fBulkAInt8D:R:BufferAInt0 $fTargetAInt$fWindowableAInt$fConvertAIntFInt$fConvertFIntAIntD:R:ArrayAInt0 $fBulkAInt ABuffer_T2 AArray_T2D:R:BufferA(,)0 $fTargetA(,)$fWindowableA(,)$fConvertA(,)T2(,)$fConvertT2(,)A(,)D:R:ArrayA(,)0 $fBulkA(,) ABuffer_Word8 AArray_Word8D:R:BufferAWord80$fTargetAWord8$fWindowableAWord8$fConvertAWord8FWord8$fConvertFWord8AWord8D:R:ArrayAWord80 $fBulkAWord8 ABuffer_Array AArray_Array$fWindowableAArrayD:R:BufferAArray0$fTargetAArray$fConvertAArrayBText$fConvertAArrayAArray$fConvertNArrayAArray$fConvertAArrayNArrayD:R:ArrayAArray0 $fBulkAArrayfindRowsStartEndABuffer_Date32 AArray_Date32D:R:BufferADate320$fTargetADate32$fWindowableADate32D:R:ArrayADate320 $fBulkADate32GHC.Showshow tabulate1 tabulate2 ABuffer_Prod AArray_ProdProd1$fMask:*:Array$fMask:*:Array0 $fMask()Array$fDiscardSArray$fDiscardZArray$fSelectSArray$fSelectZArray$fIsProdListArray$fIsProdListArray0D:R:BufferA:*:0 $fTargetA:*:$fWindowableA:*:D:R:ArrayA:*:0 $fBulkA:*:unpacksToBuffer UnpacksColumnunpacksToBuffer_MaybeCharsunpacksToBuffer_VarCharsunpacksToBuffer_VarCharStringunpacksToBuffer_VarTextunpacksToBuffer_VarTextStringunpacksToBuffer_IntAscunpacksToBuffer_IntAsc0unpacksToBuffer_DoubleAscunpacksToBuffer_DoubleFixedPackunpacksToBuffer_YYYYsMMsDDunpacksToBuffer_DDsMMsYYYY$fUnpackablesSep$fUnpackablesSep0$fUnpackablesDDsMMsYYYY$fUnpackablesYYYYsMMsDD$fUnpackablesDoubleFixedPack$fUnpackablesDoubleAsc$fUnpackablesIntAsc0$fUnpackablesIntAsc$fUnpackablesVarTextString$fUnpackablesVarText$fUnpackablesVarCharString$fUnpackablesVarChars$fUnpackablesMaybeCharsIntCharGHC.WordWord8DoublestrtodGHC.Errerror+repa-convert-4.2.3.1-GS4jlk3jzrB2lXCbTOCbtSData.Repa.Convert.Format.UnitUnitAscData.Repa.Convert.Format.TextVarText VarTextStringData.Repa.Convert.Format.ObjectmkObjectObject ObjectFormatField fieldName fieldFormat fieldIncludeData.Repa.Convert.Format.Ascii FormatAscii FormatAscii' formatAsciiData.Repa.Convert.Format.StringFixCharsVarChars VarCharString ExactCharsData.Repa.Convert.Format.SepSepSepNilSepCons SepFormatmkSep takeSepCharData.Repa.Convert.Format.Date32 YYYYsMMsDD DDsMMsYYYY Data.Repa.Convert.Format.NumericIntAscIntAsc0 DoubleAscDoubleFixedPackData.Repa.Convert.Format.Maybe MaybeChars MaybeBytesData.Repa.Convert.Format.BytesVarBytesData.Repa.Convert.Format.BinaryWord8beInt8beWord16beInt16beWord32beInt32beWord64beInt64be Float32be Float64beData.Repa.Convert.Format.AppApp#Data.Repa.Convert.Internal.PackablePackablepackpacker Unpackableunpacker!Data.Repa.Convert.Internal.FormatValue fieldCountminSize fixedSize packedSize!Data.Repa.Convert.Internal.PackerunsafeRunPackerPacker fromPacker#Data.Repa.Convert.Internal.UnpackerunsafeRunUnpackerUnpacker fromUnpacker*repa-scalar-4.2.3.1-FTQvcTbdEwv8CnrCB9isduData.Repa.Scalar.Product:*: