h)uhe      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                      0.5.5 Safe-Inferred  Safe-Inferred  Safe-Inferred )*0 comfort-array1Dynamically build a shape and its indices in the  monad. comfort-arrayShape for arrays that hold elements that can alternatively be stored in a  record. comfort-arrayShape for arrays that hold elements that can alternatively be stored in nested tuples. comfort-array(Row-major composition of two dimensions.Shape.indices (Shape.ZeroBased (3::Int) ::+ Shape.Range 'a' 'c')4[Left 0,Left 1,Left 2,Right 'a',Right 'b',Right 'c'] comfort-array is a shape, where the indices wrap around at the array boundaries. E.g.let shape = Shape.Cyclic (10::Int) in Shape.offset shape (-1) == Shape.offset shape 9This also means that there are multiple indices that address the same array element.%Shape.indices (Shape.Cyclic (7::Int))[0,1,2,3,4,5,6], comfort-arraySimplex is a generalization of 3 to more than two dimensions. Indices are tuples of fixed size with elements ordered in ascending, strictly ascending, descending or strictly descending order. "Order" refers to the index order in f;. In order to avoid confusion we suggest that the order of f is consistent with . Obviously, g implements ranking and a implements unranking of combinations (in the combinatorial sense) with or without repetitions.Shape.indices $ Shape.simplexAscending (replicate 3 Shape.AllDistinct) $ Shape.ZeroBased (4::Int)![[0,1,2],[0,1,3],[0,2,3],[1,2,3]]Shape.indices $ Shape.simplexAscending (replicate 3 Shape.SomeRepetitive) $ Shape.ZeroBased (3::Int)[[0,0,0],[0,0,1],[0,0,2],[0,1,1],[0,1,2],[0,2,2],[1,1,1],[1,1,2],[1,2,2],[2,2,2]]Shape.indices $ Shape.simplexAscending [Shape.Repetitive,Shape.Distinct,Shape.Repetitive] $ Shape.ZeroBased (4::Int)[[0,0,1],[0,0,2],[0,0,3],[0,1,2],[0,1,3],[0,2,3],[1,1,2],[1,1,3],[1,2,3],[2,2,3]]Shape.indices $ Shape.simplexAscending [Shape.Repetitive,Shape.Distinct,Shape.Distinct] $ Shape.ZeroBased (4::Int)[[0,0,1],[0,0,2],[0,0,3],[0,1,2],[0,1,3],[0,2,3],[1,1,2],[1,1,3],[1,2,3],[2,2,3]]Shape.indices $ Shape.simplexDescending (replicate 3 Shape.AllDistinct) $ Shape.ZeroBased (4::Int)![[2,1,0],[3,1,0],[3,2,0],[3,2,1]]Shape.indices $ Shape.simplexDescending (replicate 3 Shape.SomeRepetitive) $ Shape.ZeroBased (3::Int)[[0,0,0],[1,0,0],[1,1,0],[1,1,1],[2,0,0],[2,1,0],[2,1,1],[2,2,0],[2,2,1],[2,2,2]]Shape.indices $ Shape.simplexDescending [Shape.Repetitive,Shape.Distinct,Shape.Repetitive] $ Shape.ZeroBased (4::Int)[[1,1,0],[2,1,0],[2,2,0],[2,2,1],[3,1,0],[3,2,0],[3,2,1],[3,3,0],[3,3,1],[3,3,2]]Shape.indices $ Shape.simplexDescending [Shape.Repetitive,Shape.Distinct,Shape.Distinct] $ Shape.ZeroBased (4::Int)[[1,1,0],[2,1,0],[2,2,0],[2,2,1],[3,1,0],[3,2,0],[3,2,1],[3,3,0],[3,3,1],[3,3,2]]3 comfort-arrayShape.indices $ Shape.Triangular Shape.Upper $ Shape.ZeroBased (3::Int)%[(0,0),(0,1),(0,2),(1,1),(1,2),(2,2)]Shape.indices $ Shape.Triangular Shape.Lower $ Shape.ZeroBased (3::Int)%[(0,0),(1,0),(1,1),(2,0),(2,1),(2,2)]; comfort-array; is like a Cartesian product, but it is statically asserted that both dimension shapes match.5Shape.indices $ Shape.Cube $ Shape.ZeroBased (2::Int)[(0,0,0),(0,0,1),(0,1,0),(0,1,1),(1,0,0),(1,0,1),(1,1,0),(1,1,1)]> comfort-array> is like a Cartesian product, but it is statically asserted that both dimension shapes match.7Shape.indices $ Shape.Square $ Shape.ZeroBased (3::Int)7[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]A comfort-arrayA has an  instance that is based on the storage order in memory. This way, you can put A values in a  or use them as keys in a  even if Index sh has no 1 instance. The downside is, that the ordering of DeferredIndex sh may differ from the one of Index sh.C comfort-arrayThis data type wraps another array shape. Its index type is a wrapped 3. The advantages are: No conversion forth and back  and Index sh. You can convert once using } and ~ whenever you need your application specific index type. No need for e.g. Storable (Index sh) , because  is already  . You get d and `# instances without the need for an e type. The disadvantage is: A deferred index should be bound to a specific shape, but this is not checked. That is, you may obtain a deferred index for one shape and accidentally abuse it for another shape without a warning.Example:let sh2 = (Shape.ZeroBased (2::Int), Shape.ZeroBased (2::Int)) in let sh3 = (Shape.ZeroBased (3::Int), Shape.ZeroBased (3::Int)) in (Shape.offset sh3 $ Shape.indexFromOffset sh2 3, Shape.offset (Shape.Deferred sh3) $ Shape.indexFromOffset (Shape.Deferred sh2) 3)(4,3)E comfort-arrayE2 denotes a shape of fixed size that is defined by  and 3 methods. For correctness it is necessary that the  and  instances are properly implemented. Automatically derived instances are fine.?Shape.indices (Shape.Enumeration :: Shape.Enumeration Ordering) [LT,EQ,GT]G comfort-arrayG; denotes a range defined by the start index and the length.+Shape.indices (Shape.Shifted (-4) (8::Int))[-4,-3,-2,-1,0,1,2,3]K comfort-arrayK denotes an inclusive range like those of the Haskell 98 standard Array type from the array package. E.g. the shape type (Range Int32, Range Int64) is equivalent to the ix type (Int32, Int64) for Arrays.)Shape.indices (Shape.Range (-5) (5::Int))[-5,-4,-3,-2,-1,0,1,2,3,4,5]3Shape.indices (Shape.Range (-1,-1) (1::Int,1::Int))=[(-1,-1),(-1,0),(-1,1),(0,-1),(0,0),(0,1),(1,-1),(1,0),(1,1)]O comfort-arrayO: denotes a range starting at one and has a certain length.'Shape.indices (Shape.OneBased (7::Int))[1,2,3,4,5,6,7]R comfort-arrayR; denotes a range starting at zero and has a certain length.(Shape.indices (Shape.ZeroBased (7::Int))[0,1,2,3,4,5,6]Y comfort-arrayWe cannot use  because  instances for () and '(a,b)' are already defined in a way, that is incompatible for our needs.a comfort-arrayIt should hold 'indexFromOffset sh k == indices sh !! k , but a should generally be faster.n comfort-array#Shape types, that is, instances of n, that are also instance of , must have proper  instances, otherwise evil memory corruption will occur. At least, it must hold 1sh0 == sh1 ==> Shape.size sh0 == Shape.size sh1. comfort-array?@;<=34569:7821,-./0&%+*'()$"# !  nodefjghimkl`abc{^_[\]YZWXvprqstuwxzyUVRST|OPQKLMNGHIJEFCDAB}~>?@;<=34569:7821,-./0&%+*'()$"# !  557776 Safe-Inferred1 Safe-Inferred)*1 Safe-Inferred2= comfort-array1Compute the sizes of a shape and some sub-shapes. Safe-Inferred2   Safe-Inferred3 Safe-Inferred6 comfort-array\(QC.NonNegative n) (ArrayChar x) -> x == Array.mapShape (Shape.ZeroBased . Shape.size) (Array.append (Array.take n x) (Array.drop n x)) comfort-array\(QC.NonNegative n) (ArrayChar x) -> x == Array.mapShape (Shape.ZeroBased . Shape.size) (Array.append (Array.take n x) (Array.drop n x)) comfort-array\(ArrayChar x) (ArrayChar y) -> let xy = Array.append x y in x == Array.takeLeft xy && y == Array.takeRight xy comfort-array\(ArrayChar x) (ArrayChar y) (ArrayChar z) -> let xyz = Array.append x $ Array.append y z in y == Array.takeCenter xyz comfort-arrayWe must restrict  to ^ because of >. Because the shape is static, we do not need a size check in .9 5 Safe-Inferred6 Safe-Inferred7 comfort-arrayQC.forAll genArray2 $ \xs -> let shape = Array.shape xs in Shape.size shape > 0 QC.==> QC.forAll (QC.elements $ Shape.indices shape) $ \(ix0,ix1) -> Array.pick xs ix0 ! ix1 == xs!(ix0,ix1)""9  Safe-Inferred8l   Safe-Inferred8 Safe-Inferred8  Safe-Inferred99  Safe-Inferred9  Safe-Inferred:  Safe-Inferred:    Safe-Inferred;B  Safe-Inferred> comfort-array-\x -> Array.singleton x ! () == (x::Word16) comfort-array\(QC.NonNegative n) (Array16 x) -> x == Array.mapShape (Shape.ZeroBased . Shape.size) (Array.append (Array.take n x) (Array.drop n x)) comfort-array\(QC.NonNegative n) (Array16 x) -> x == Array.mapShape (Shape.ZeroBased . Shape.size) (Array.append (Array.take n x) (Array.drop n x)) comfort-array\(Array16 x) (Array16 y) -> let xy = Array.append x y in x == Array.takeLeft xy && y == Array.takeRight xy comfort-array\(Array16 x) (Array16 y) (Array16 z) -> let xyz = Array.append x $ Array.append y z in y == Array.takeCenter xyz comfort-array8\(Array16 xs) -> Array.sum xs == sum (Array.toList xs) comfort-array\(Array16 xs) -> Array.product xs == product (Array.toList xs)""5 Safe-Inferred^[ comfort-arrayQC.forAll genNonEmptyArray2 $ \xs -> QC.forAll (QC.elements $ Shape.indices $ Array.shape xs) $ \(ix0,ix1) -> Array2.takeRow xs ix0 ! ix1 == xs!(ix0,ix1) comfort-arrayIt is a checked error if a row width differs from the result array width.QC.forAll genArray2 $ \xs -> xs == Array2.fromRowArray (snd $ Array.shape xs) (Array2.toRowArray xs) comfort-arrayQC.forAll genArray2 $ \xs -> let (Shape.ZeroBased m, width) = Array.shape xs in QC.forAll (QC.choose (0, m)) $ \k -> let ys = Array.reshape (Shape.ZeroBased k ::+ Shape.ZeroBased (m-k), width) xs in ys == Array2.above (Array2.takeTop ys) (Array2.takeBottom ys) comfort-arrayQC.forAll genArray2 $ \xs -> let (height, Shape.ZeroBased n) = Array.shape xs in QC.forAll (QC.choose (0, n)) $ \k -> let ys = Array.reshape (height, Shape.ZeroBased k ::+ Shape.ZeroBased (n-k)) xs in ys == Array2.beside (Array2.takeLeft ys) (Array2.takeRight ys) comfort-arrayOnly the outer  BoxedArray need to be non-empty.let shapeR0 = shapeInt 2; shapeR1 = shapeInt 3 in let shapeC0 = shapeInt 3; shapeC1 = shapeInt 2 in let block sh a = Array.replicate sh (a::Word16) in Array2.fromBlockArray (Map.singleton 'A' shapeR0 <> Map.singleton 'B' shapeR1) (Map.singleton '1' shapeC0 <> Map.singleton '2' shapeC1) $ BoxedArray.fromList (Set.fromList "AB", Set.fromList "12") [block (shapeR0,shapeC0) 0, block (shapeR0,shapeC1) 1, block (shapeR1,shapeC0) 2, block (shapeR1,shapeC1) 3]StorableArray.fromList (fromList [('A',ZeroBased {... 2}),('B',ZeroBased {... 3})],fromList [('1',ZeroBased {... 3}),('2',ZeroBased {... 2})]) [0,0,0,1,1,0,0,0,1,1,2,2,2,3,3,2,2,2,3,3,2,2,2,3,3]QC.forAll genArray2 $ \blockA1 -> QC.forAll genArray2 $ \blockB2 -> let shapeR0 = fst $ Array.shape blockA1 in let shapeC0 = snd $ Array.shape blockA1 in let shapeR1 = fst $ Array.shape blockB2 in let shapeC1 = snd $ Array.shape blockB2 in QC.forAll (genArrayForShape (shapeR0, shapeC1)) $ \blockA2 -> QC.forAll (genArrayForShape (shapeR1, shapeC0)) $ \blockB1 -> let blocked = BoxedArray.fromList (Set.fromList "AB", Set.fromList "12") [blockA1, blockA2, blockB1, blockB2] in transpose (Array2.fromNonEmptyBlockArray blocked) QC.=== Array2.fromNonEmptyBlockArray (TestBoxedArray.transpose (fmap transpose blocked))QC.forAll genArray2 $ \blockA1 -> QC.forAll genArray2 $ \blockB2 -> QC.forAll genArray2 $ \blockC3 -> let shapeR0 = fst $ Array.shape blockA1 in let shapeC0 = snd $ Array.shape blockA1 in let shapeR1 = fst $ Array.shape blockB2 in let shapeC1 = snd $ Array.shape blockB2 in let shapeR2 = fst $ Array.shape blockC3 in let shapeC2 = snd $ Array.shape blockC3 in QC.forAll (genArrayForShape (shapeR0, shapeC1)) $ \blockA2 -> QC.forAll (genArrayForShape (shapeR0, shapeC2)) $ \blockA3 -> QC.forAll (genArrayForShape (shapeR1, shapeC0)) $ \blockB1 -> QC.forAll (genArrayForShape (shapeR1, shapeC2)) $ \blockB3 -> QC.forAll (genArrayForShape (shapeR2, shapeC0)) $ \blockC1 -> QC.forAll (genArrayForShape (shapeR2, shapeC1)) $ \blockC2 -> let blocked = BoxedArray.fromList (Set.fromList "ABC", Set.fromList "123") [blockA1, blockA2, blockA3, blockB1, blockB2, blockB3, blockC1, blockC2, blockC3] in transpose (Array2.fromNonEmptyBlockArray blocked) QC.=== Array2.fromNonEmptyBlockArray (TestBoxedArray.transpose (fmap transpose blocked)) comfort-arrayExplicit parameters for the shape of the result matrix allow for working with arrays of zero rows or columns.(id :: Id (array (height, Map Char ShapeInt) Word16)) $ Array2.fromBlockArray (Map.singleton 'A' (shapeInt 2) <> Map.singleton 'B' (shapeInt 3)) Map.empty $ BoxedArray.fromList (Set.fromList "AB", Set.empty) []StorableArray.fromList (fromList [('A',ZeroBased {... 2}),('B',ZeroBased {... 3})],fromList []) []QC.forAll genArray2 $ \block -> let height = Map.singleton 'A' $ fst $ Array.shape block in let width = Map.singleton '1' $ snd $ Array.shape block in Array.reshape (height,width) block QC.=== Array2.fromBlockArray height width (BoxedArray.replicate (Set.singleton 'A', Set.singleton '1') block) comfort-arrayQC.forAll genArray2 $ \blockA1 -> QC.forAll genArray2 $ \blockB2 -> let shapeR0 = fst $ Array.shape blockA1 in let shapeC0 = snd $ Array.shape blockA1 in let shapeR1 = fst $ Array.shape blockB2 in let shapeC1 = snd $ Array.shape blockB2 in let shapeR = shapeR0::+shapeR1::+Shape.Zero in let shapeC = shapeC0::+shapeC1::+Shape.Zero in QC.forAll (genArrayForShape (shapeR0, shapeC1)) $ \blockA2 -> QC.forAll (genArrayForShape (shapeR1, shapeC0)) $ \blockB1 -> let blocked = BoxedArray.fromList (Set.fromList "AB", Set.fromList "12") [blockA1, blockA2, blockB1, blockB2] in Array.reshape (shapeR, shapeC) (Array2.fromNonEmptyBlockArray blocked) QC.=== Array2.fromBlocks shapeR shapeC Proxy blockA1 blockA2 blockB1 blockB2 comfort-arrayQC.forAll genArray2 $ \blockA1 -> QC.forAll genArray2 $ \blockB3 -> QC.forAll (liftA2 (\char0 char1 -> Shape.Range (min char0 char1) (max char0 char1)) (QC.choose ('a','k')) (QC.choose ('a','k'))) $ \shapeC1 -> let shapeR0 = fst $ Array.shape blockA1 in let shapeC0 = snd $ Array.shape blockA1 in let shapeR1 = fst $ Array.shape blockB3 in let shapeC2 = snd $ Array.shape blockB3 in QC.forAll (genArrayForShape (shapeR0, shapeC1)) $ \blockA2 -> QC.forAll (genArrayForShape (shapeR0, shapeC2)) $ \blockA3 -> QC.forAll (genArrayForShape (shapeR1, shapeC0)) $ \blockB1 -> QC.forAll (genArrayForShape (shapeR1, shapeC1)) $ \blockB2 -> Array2.fromBlockMatrix (blockA1 &||| Array2.beside blockA2 blockA3 &=== blockB1 &||| blockB2 &||| blockB3) QC.=== Array.reshape (shapeR0::+shapeR1, shapeC0::+shapeC1::+shapeC2) (Array2.fromBlocks (shapeR0::+shapeR1::+Shape.Zero) (shapeC0::+shapeC1::+shapeC2::+Shape.Zero) Proxy blockA1 blockA2 blockA3 blockB1 blockB2 blockB3) QC.forAll (liftA2 (\char0 char1 -> Shape.Range (min char0 char1) (max char0 char1)) (QC.choose ('a','k')) (QC.choose ('a','k'))) $ \shapeR0 -> QC.forAll (liftA2 Shape.Shifted (QC.choose (-10,10)) (QC.choose (0,10::Int))) $ \shapeR1 -> let shapeR2 = () in QC.forAll (fmap Shape.ZeroBased (QC.choose (0,10::Int))) $ \shapeC0 -> QC.forAll (fmap Shape.OneBased (QC.choose (0,10::Int))) $ \shapeC1 -> let shapeC2 :: Shape.Enumeration Ordering shapeC2 = Shape.Enumeration in QC.forAll (genArrayForShape (shapeR0, shapeC0)) $ \blockA1 -> QC.forAll (genArrayForShape (shapeR0, shapeC1)) $ \blockA2 -> QC.forAll (genArrayForShape (shapeR0, shapeC2)) $ \blockA3 -> QC.forAll (genArrayForShape (shapeR1, shapeC0)) $ \blockB1 -> QC.forAll (genArrayForShape (shapeR1, shapeC1)) $ \blockB2 -> QC.forAll (genArrayForShape (shapeR1, shapeC2)) $ \blockB3 -> QC.forAll (genArrayForShape (shapeR2, shapeC0)) $ \blockC1 -> QC.forAll (genArrayForShape (shapeR2, shapeC1)) $ \blockC2 -> QC.forAll (genArrayForShape (shapeR2, shapeC2)) $ \blockC3 -> Array2.fromBlockMatrix (blockA1 &||| blockA2 &||| blockA3 &=== blockB1 &||| blockB2 &||| blockB3 &=== blockC1 &||| blockC2 &||| blockC3) QC.=== Array2.beside (Array2.above blockA1 $ Array2.above blockB1 blockC1) (Array2.above (Array2.beside blockA2 blockA3) (Array2.beside (Array2.above blockB2 blockC2) (Array2.above blockB3 blockC3)))2323 Safe-Inferredd comfort-array#Array.fromList (shapeInt 5) ['a'..]>StorableArray.fromList (ZeroBased {zeroBasedSize = 5}) "abcde" comfort-arrayArray.fromTuple ('a',('b','c')) :: Array (Shape.NestedTuple Shape.TupleIndex (X,(X,X))) CharStorableArray.fromList (NestedTuple {getNestedTuple = (Element 0,(Element 1,Element 2))}) "abc"let arr :: Array (Shape.NestedTuple Shape.TupleAccessor (X,(X,X))) Char arr = Array.fromTuple ('a',('b','c')) in (arr ! fst, arr ! (fst.snd)) ('a','b') comfort-arraylet arr = Array.fromRecord ('a' :+ 'b') in let (real:+imag) = Shape.indexRecordFromShape $ Array.shape arr in (arr ! real, arr ! imag) ('a','b') comfort-arrayArray.takeSet (Set.fromList [0,2,4,7,13]) (Array.vectorFromList [3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3::Word8])/StorableArray... (... [0,2,4,7,13]) [3,4,5,6,7] comfort-arrayArray.takeIntSet (IntSet.fromList [0,2,4,7,13]) (Array.vectorFromList [3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3::Word8])/StorableArray... (... [0,2,4,7,13]) [3,4,5,6,7] comfort-array-It is a checked error if the vector is empty.forAllNonEmpty $ \xs -> Array.minimum xs ==? minimum (Array.toList xs) comfort-array-It is a checked error if the vector is empty.forAllNonEmpty $ \xs -> Array.maximum xs ==? maximum (Array.toList xs) comfort-arrayforAllNonEmpty $ \xs -> Array.limits xs ==? (Array.minimum xs, Array.maximum xs)::9  !"#$%&''()**+,,--./012334456789::9;;<=>?@AABCDDEEFFGHHIJJKKLLMMNOPPQRSSTUUVWWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~o[efgno[g                  [                                           [         hibc*comfort-array-0.5.5-inplaceData.Array.Comfort.ShapeData.Array.Comfort.Shape.Test Data.Array.Comfort.Shape.SubSizeData.Array.Comfort.Container"Data.Array.Comfort.Boxed.UncheckedData.Array.Comfort.BoxedData.Array.Comfort.Bool+Data.Array.Comfort.Storable.Mutable.Private#Data.Array.Comfort.Storable.Private#Data.Array.Comfort.Storable.Mutable-Data.Array.Comfort.Storable.Unchecked.Creator-Data.Array.Comfort.Storable.Unchecked.Monadic%Data.Array.Comfort.Storable.Unchecked Data.Array.Comfort.Storable.Dim2Data.Array.Comfort.Storable comfort-arrayData.Array.Comfort.Shape.Set Data.Array.Comfort.Shape.UtilityData.Array.Comfort.Shape.TupleData.Array.Comfort.Check)Data.Array.Comfort.Boxed.Strict.Unchecked"Data.Array.Comfort.Storable.Memory-Data.Array.Comfort.Storable.Mutable.UncheckedmessageIndexFromOffset Construction ConsIndex Constructed FieldIndexRecord getRecord ElementIndex StaticTuple staticTuple AccessorTupletupleAccessors ElementTuple DataTuple indexTupleAElement TupleIndex TupleAccessor NestedTuplegetNestedTuple::+Cyclic cyclicSize CollisionC CollisionDistinct RepetitiveSomeRepetitive AllDistinct SimplexOrderCSimplexDescendingSimplexAscending SimplexOrder Ascending DescendingSimplex simplexOrdersimplexDimension simplexSizeUpperTriangularLowerTriangular TriangulartriangularParttriangularSizeUpperLowerCubecubeSizeSquare squareSize DeferredIndexDeferred EnumerationShifted shiftedOffset shiftedSizeRange rangeFromrangeToOneBased oneBasedSize ZeroBased zeroBasedSizeZero AppendMonoidemptyAppendSemigroupappendPattern DataPattern indexPatternStaticstatic InvIndexedindexFromOffsetuncheckedIndexFromOffsetunifiedIndexFromOffsetIndexedIndexindicesoffsetuncheckedOffset unifiedOffsetinBounds sizeOffsetuncheckedSizeOffsetunifiedSizeOffsetCsizeCheckSingletonChecked UncheckedCheckingResult switchCheck requireCheck runChecked runUnchecked throwOrErrorassertassertIndexFromOffsetzeroBasedSplit deferIndex revealIndexcartesianFromSquarecartesianFromCubelowerTriangularupperTriangular triangleSize triangleRootsimplexAscendingsimplexDescendingindexTupleFromShapeindexRecordFromShape construct consIndex$fCheckingUnchecked$fCheckingChecked $fMonadResult$fApplicativeResult$fFunctorResult $fEqResult$fC(,,)$fC(,) $fCTagged $fCIntMap$fCMap $fCIntSet$fCSet$fC() $fIndexed(,,) $fIndexed(,)$fIndexedTagged$fIndexedIntMap $fIndexedMap$fIndexedIntSet $fIndexedSet $fIndexed()$fInvIndexed(,,)$fInvIndexed(,)$fInvIndexedTagged$fInvIndexedIntMap$fInvIndexedMap$fInvIndexedIntSet$fInvIndexedSet$fInvIndexed() $fStatic(,,) $fStatic(,)$fStaticTagged $fStatic()$fPatternTagged $fPattern()$fAppendSemigroup(,,)$fAppendSemigroup(,)$fAppendMonoidZero$fAppendSemigroupZero $fStaticZero$fCZero$fPatternZeroBased$fAppendMonoidZeroBased$fAppendSemigroupZeroBased$fInvIndexedZeroBased $fCZeroBased$fStorableZeroBased$fNFDataZeroBased$fApplicativeZeroBased$fFunctorZeroBased$fAppendMonoidOneBased$fAppendSemigroupOneBased$fInvIndexedOneBased $fCOneBased$fStorableOneBased$fNFDataOneBased$fApplicativeOneBased$fFunctorOneBased$fStorableRange$fInvIndexedRange$fIndexedRange$fCRange $fNFDataRange$fFunctorRange$fStorableShifted$fInvIndexedShifted$fIndexedShifted $fCShifted$fNFDataShifted$fFunctorShifted$fIndexedOneBased$fIndexedZeroBased$fStorableEnumeration$fStaticEnumeration$fInvIndexedEnumeration$fIndexedEnumeration$fCEnumeration$fNFDataEnumeration$fStaticDeferred $fCDeferred$fNFDataDeferred$fStorableDeferredIndex$fInvIndexedDeferred$fIndexedDeferred$fInvIndexedSquare$fIndexedSquare $fCSquare$fStorableSquare$fNFDataSquare$fApplicativeSquare$fFunctorSquare$fPatternSquare $fPattern(,)$fInvIndexedCube $fIndexedCube$fCCube$fStorableCube $fNFDataCube$fApplicativeCube $fFunctorCube$fTriangularPartUpper$fTriangularPartLower$fStaticTriangular$fInvIndexedTriangular$fIndexedTriangular $fCTriangular$fEqTriangular$fNFDataTriangular$fShowSimplexOrder$fEqSimplexOrder $fShowSimplex$fSimplexOrderCDescending$fSimplexOrderCAscending$fInvIndexedSimplex$fIndexedSimplex $fCSimplex$fCollisionCCollision$fCollisionCSomeRepetitive$fCollisionCAllDistinct$fInvIndexedCyclic$fIndexedCyclic $fCCyclic$fStorableCyclic$fNFDataCyclic$fApplicativeCyclic$fFunctorCyclic $fPattern::+ $fStatic::+$fInvIndexed::+ $fIndexed::+$fC::+ $fNFData::+$fNFDataElement$fCNestedTuple$fElementTupleComplex$fElementTuple(,,,)$fElementTuple(,,)$fElementTuple(,)$fElementTupleElement$fElementTuple()$fMonadStrictUnitWriter$fApplicativeStrictUnitWriter$fFunctorStrictUnitWriter$fNFDataNestedTuple$fIndexedNestedTuple$fAccessorTupleComplex$fAccessorTuple(,,,)$fAccessorTuple(,,)$fAccessorTuple(,)$fAccessorTupleElement$fAccessorTuple()$fStaticNestedTuple$fStaticTupleComplex$fStaticTuple(,,,)$fStaticTuple(,,)$fStaticTuple(,)$fStaticTupleElement$fStaticTuple()$fPatternNestedTuple$fIndexedNestedTuple0$fStaticRecord $fCRecord $fEqRecord$fIndexedRecord$fCConstructed$fInvIndexedConstructed$fIndexedConstructed$fMonadConstruction$fApplicativeConstruction$fFunctorConstruction $fEqConsIndex$fShowConsIndex$fEqConstructed$fShowConstructed$fEqFieldIndex$fShowFieldIndex$fEqElementIndex$fOrdElementIndex$fShowElementIndex $fEqElement $fShowElement$fEqNestedTuple$fShowNestedTuple$fEq::+ $fShow::+ $fEqCyclic $fShowCyclic$fShowCollision $fEqCollision$fOrdCollision$fEnumCollision$fShowSomeRepetitive$fEqSomeRepetitive$fShowAllDistinct$fEqAllDistinct$fShowTriangular $fEqUpper $fShowUpper $fEqLower $fShowLower$fEqCube $fShowCube $fEqSquare $fShowSquare$fEqDeferredIndex$fOrdDeferredIndex$fShowDeferredIndex $fEqDeferred$fShowDeferred$fEqEnumeration$fShowEnumeration $fEqShifted $fShowShifted $fEqRange $fShowRange $fEqOneBased$fShowOneBased $fEqZeroBased$fShowZeroBased$fEqZero $fOrdZero $fShowZerotestsAtomToShapeevaluateSubTConsmeasureautoatomsubpairtriple$fCSub$fCAtomEqShapeeqShapeNFShapernfShapeShape shapeSizefromListtoShape$fCT$fCT0$fCT1$fC[]$fCShape $fNFShapeT $fNFShapeMap $fNFShapeT0 $fNFShapeT1 $fNFShape[] $fNFDataShape $fEqShapeT $fEqShapeMap $fEqShapeT0 $fEqShapeT1 $fEqShape[] $fEqShape $fIndexedT $fIndexedT0 $fIndexed[]$fIndexedShape $fShowShape $fShowShape0 $fShowShape1 $fShowShape2ArrayshapebufferreshapemapShape!toListvectorFromList replicatemapzipWithtakedroptakeLeft takeRightsplit takeCenter$fTraversableArray$fFoldableArray$fApplicativeArray$fFunctorArray $fNFDataArray $fShowArray $fEqArrayfromMaptoMap fromTupletoTuple fromRecordtoRecord fromContainer toContainer accessMaybe// accumulatetoAssociationsfromAssociationspick cartesianfromSettoSetmemberunion intersection differenceIOArraySTArraycopycreatecreateWithSizecreateWithSizeAndResult unsafeCreateunsafeCreateWithSizeunsafeCreateWithSizeAndResultunsafeArrayIOToPrimshow withArrayPtrwithPtrread readMaybe readEitherwriteupdatenewfreezethaw unsafeFreeze unsafeThaw $fMonoidArray$fSemigroupArrayCreatorliftIO liftContT unsafeRununsafeRunWithResultcreateWithSizes$fBiapplicativeCreator$fBifunctorCreator$fFunctorCreatorunsafeCreateWithSizesunsafeCreateWithSizesAndResult_unsafeCreateWithSizesAndResultunsafeCreateWithAutoSizesfromStorableVectortoStorableVector mapWithIndex singletonsumproductfoldlBlock BlockMatrix BlockArray RowFunction BlockFunction ShapeSequenceswitchSequenceArray2 singleRow singleColumn flattenRow flattenColumntakeRow toRowArray fromRowArrayabovebesidetakeTop takeBottomfromNonEmptyBlockArrayfromBlockArray fromBlocksblock blockAbove blockBeside&===&|||fromBlockMatrix$fShapeSequence::+$fShapeSequenceZero $fBlockArray$fBlockBlockArray fromIntMaptoIntMapsample fromBoxedtoBoxedfromBlockArray1fromNonEmptyBlockArray2fromBlockArray2takeSet takeIntSetminimummaximumfoldl1limitsfoldMap argMinimum argMaximumerrorIndexFromOffsetisRightbaseData.Traversable Traversableghc-prim GHC.Classes<=Ordcontainers-0.6.7Data.Set.InternalSetData.Map.InternalMap GHC.TypesIntForeign.StorableStorableGHC.EnumEnumBoundedGHC.Base SemigroupEqData.IntMap.InternalIntMap CheckedResultUncheckedResult getChecked getUnchecked combineOffsetcombineSizeOffset|*|+|deconsgetconsnext Applicativepure<*>