-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Initial project template from stack
--   
--   Pure haskell vector<i>matrix</i>tensor library. Features
--   dimensionality type-checking for all operations. Generic n-dimensional
--   versions are implemented using low-level prim ops. Allows ad-hoc
--   replacement with fixed low-dimensionality vectors and matrices without
--   changing user interface.
@package easytensor
@version 0.2.0.0


module Numeric.Commons

-- | Facilities to convert to and from raw byte array. Warning! offsets and
--   sizes are in elements, not in bytes! Therefore one must be really
--   carefull if having a crazy idea of converting between types of
--   different element sizes.
class PrimBytes (a :: Type)

-- | Store content of a data type in a primitive byte array (ElementOffset,
--   NumberOfElements, ByteArrayContent )
toBytes :: PrimBytes a => a -> (# Int#, Int#, ByteArray# #)

-- | Load content of a data type from a primitive byte array
--   (ElementOffset, NumberOfElements, ByteArrayContent )
fromBytes :: PrimBytes a => (# Int#, Int#, ByteArray# #) -> a

-- | Size of a data type in bytes
byteSize :: PrimBytes a => a -> Int#

-- | Alignment of a data type in bytes
byteAlign :: PrimBytes a => a -> Int#

-- | Size of a conainer type elements in bytes
elementByteSize :: PrimBytes a => a -> Int#

-- | Primitive indexing
ix :: PrimBytes a => Int# -> a -> (ElemPrim a :: TYPE (ElemRep a))
type FloatBytes a = (PrimBytes a, ElemRep a ~ FloatRep, ElemPrim a ~ Float#)
type DoubleBytes a = (PrimBytes a, ElemRep a ~ DoubleRep, ElemPrim a ~ Double#)
type IntBytes a = (PrimBytes a, ElemRep a ~ IntRep, ElemPrim a ~ Int#)
type WordBytes a = (PrimBytes a, ElemRep a ~ WordRep, ElemPrim a ~ Word#)
instance Numeric.Commons.PrimBytes GHC.Types.Float
instance Numeric.Commons.PrimBytes GHC.Types.Double
instance Numeric.Commons.PrimBytes GHC.Types.Int
instance Numeric.Commons.PrimBytes GHC.Int.Int8
instance Numeric.Commons.PrimBytes GHC.Int.Int16
instance Numeric.Commons.PrimBytes GHC.Int.Int32
instance Numeric.Commons.PrimBytes GHC.Int.Int64
instance Numeric.Commons.PrimBytes GHC.Types.Word
instance Numeric.Commons.PrimBytes GHC.Word.Word8
instance Numeric.Commons.PrimBytes GHC.Word.Word16
instance Numeric.Commons.PrimBytes GHC.Word.Word32
instance Numeric.Commons.PrimBytes GHC.Word.Word64


module Numeric.Scalar

-- | Alias for zero-dimensional DataFrame
type Scalar t = DataFrame t ('[] :: [Nat])

-- | Convert scalar back to ordinary type
unScalar :: Scalar t -> t

-- | Convert any type to scalar wrapper
scalar :: t -> Scalar t
type Scf = Scalar Float
type Scd = Scalar Double


-- | Mutable DataFrames living in IO.
module Numeric.DataFrame.IO
class MutableFrame t (ns :: [Nat])

-- | Mutable DataFrame that lives in IO. Internal representation is always
--   a ByteArray.
data IODataFrame t (ns :: [Nat])

-- | Create a new mutable DataFrame.
newDataFrame :: forall t (ns :: [Nat]). (PrimBytes t, Dimensions ns) => IO (IODataFrame t ns)

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
copyDataFrame :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]). (PrimBytes (DataFrame t as), ConcatList as bs asbs, Dimensions bs) => DataFrame t as -> Idx bs -> IODataFrame t asbs -> IO ()

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
copyMutableDataFrame :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]). (PrimBytes t, ConcatList as bs asbs, Dimensions bs) => IODataFrame t as -> Idx bs -> IODataFrame t asbs -> IO ()

-- | Make a mutable DataFrame immutable, without copying.
unsafeFreezeDataFrame :: forall t (ns :: [Nat]). PrimBytes (DataFrame t ns) => IODataFrame t ns -> IO (DataFrame t ns)

-- | Copy content of a mutable DataFrame into a new immutable DataFrame.
freezeDataFrame :: forall t (ns :: [Nat]). PrimBytes (DataFrame t ns) => IODataFrame t ns -> IO (DataFrame t ns)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there.
thawDataFrame :: forall t (ns :: [Nat]). PrimBytes (DataFrame t ns) => DataFrame t ns -> IO (IODataFrame t ns)

-- | Write a single element at the specified index
writeDataFrame :: forall t (ns :: [Nat]). (MutableFrame t ns, Dimensions ns) => IODataFrame t ns -> Idx ns -> Scalar t -> IO ()

-- | Read a single element at the specified index
readDataFrame :: forall t (ns :: [Nat]). (MutableFrame t ns, Dimensions ns) => IODataFrame t ns -> Idx ns -> IO (Scalar t)

-- | Write a single element at the specified element offset
writeDataFrameOff :: forall t (ns :: [Nat]). (MutableFrame t ns, Dimensions ns) => IODataFrame t ns -> Int -> Scalar t -> IO ()

-- | Read a single element at the specified element offset
readDataFrameOff :: forall t (ns :: [Nat]). (MutableFrame t ns, Dimensions ns) => IODataFrame t ns -> Int -> IO (Scalar t)


-- | Mutable DataFrames living in ST.
module Numeric.DataFrame.ST
class MutableFrame t (ns :: [Nat])

-- | Mutable DataFrame that lives in ST. Internal representation is always
--   a ByteArray.
data STDataFrame s t (ns :: [Nat])

-- | Create a new mutable DataFrame.
newDataFrame :: forall t (ns :: [Nat]) s. (PrimBytes t, Dimensions ns) => ST s (STDataFrame s t ns)

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
copyDataFrame :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) s. (PrimBytes (DataFrame t as), ConcatList as bs asbs, Dimensions bs) => DataFrame t as -> Idx bs -> STDataFrame s t asbs -> ST s ()

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
copyMutableDataFrame :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) s. (PrimBytes t, ConcatList as bs asbs, Dimensions bs) => STDataFrame s t as -> Idx bs -> STDataFrame s t asbs -> ST s ()

-- | Make a mutable DataFrame immutable, without copying.
unsafeFreezeDataFrame :: forall t (ns :: [Nat]) s. PrimBytes (DataFrame t ns) => STDataFrame s t ns -> ST s (DataFrame t ns)

-- | Copy content of a mutable DataFrame into a new immutable DataFrame.
freezeDataFrame :: forall t (ns :: [Nat]) s. PrimBytes (DataFrame t ns) => STDataFrame s t ns -> ST s (DataFrame t ns)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there.
thawDataFrame :: forall t (ns :: [Nat]) s. PrimBytes (DataFrame t ns) => DataFrame t ns -> ST s (STDataFrame s t ns)

-- | Write a single element at the specified index
writeDataFrame :: forall t (ns :: [Nat]) s. (MutableFrame t ns, Dimensions ns) => STDataFrame s t ns -> Idx ns -> Scalar t -> ST s ()

-- | Read a single element at the specified index
readDataFrame :: forall t (ns :: [Nat]) s. (MutableFrame t ns, Dimensions ns) => STDataFrame s t ns -> Idx ns -> ST s (Scalar t)

-- | Write a single element at the specified element offset
writeDataFrameOff :: forall t (ns :: [Nat]) s. (MutableFrame t ns, Dimensions ns) => STDataFrame s t ns -> Int -> Scalar t -> ST s ()

-- | Read a single element at the specified element offset
readDataFrameOff :: forall t (ns :: [Nat]) s. (MutableFrame t ns, Dimensions ns) => STDataFrame s t ns -> Int -> ST s (Scalar t)


module Numeric.Vector
type Vector t (n :: Nat) = DataFrame t '[n]
type Vec2f = Vector Float 2
type Vec3f = Vector Float 3
type Vec4f = Vector Float 4
type Vec2d = Vector Double 2
type Vec3d = Vector Double 3
type Vec4d = Vector Double 4

-- | Scalar product -- sum of Vecs' components products, propagated into
--   whole Vec
(.*.) :: (Num t, Num (Vector t n), ElementWise (Idx '[n]) t (Vector t n)) => Vector t n -> Vector t n -> Vector t n
infixl 7 .*.

-- | Scalar product -- sum of Vecs' components products -- a scalar
dot :: (Num t, Num (Vector t n), ElementWise (Idx '[n]) t (Vector t n)) => Vector t n -> Vector t n -> Scalar t

-- | Dot product of two vectors
(·) :: (Num t, Num (Vector t n), ElementWise (Idx '[n]) t (Vector t n)) => Vector t n -> Vector t n -> Scalar t
infixl 7 `·`

-- | Sum of absolute values
normL1 :: (Num t, ElementWise (Idx '[n]) t (Vector t n)) => Vector t n -> Scalar t

-- | hypot function (square root of squares)
normL2 :: (Floating t, ElementWise (Idx '[n]) t (Vector t n)) => Vector t n -> Scalar t

-- | Maximum of absolute values
normLPInf :: (Ord t, Num t, ElementWise (Idx '[n]) t (Vector t n)) => Vector t n -> Scalar t

-- | Minimum of absolute values
normLNInf :: (Ord t, Num t, ElementWise (Idx '[n]) t (Vector t n)) => Vector t n -> Scalar t

-- | Norm in Lp space
normLP :: (Floating t, ElementWise (Idx '[n]) t (Vector t n)) => Int -> Vector t n -> Scalar t

-- | Compose a 2D vector
vec2 :: ElementWise (Idx '[2]) t (Vector t 2) => t -> t -> Vector t 2

-- | Compose a 3D vector
vec3 :: ElementWise (Idx '[3]) t (Vector t 3) => t -> t -> t -> Vector t 3

-- | Compose a 3D vector
vec4 :: ElementWise (Idx '[4]) t (Vector t 4) => t -> t -> t -> t -> Vector t 4

-- | Take a determinant of a matrix composed from two 2D vectors. Like a
--   cross product in 2D.
det2 :: (ElementWise (Idx '[2]) t (Vector t 2), Num t) => Vector t 2 -> Vector t 2 -> Scalar t

-- | Cross product
cross :: (ElementWise (Idx '[3]) t (Vector t 3), Num t) => Vector t 3 -> Vector t 3 -> Vector t 3

-- | Cross product for two vectors in 3D
(×) :: (ElementWise (Idx '[3]) t (Vector t 3), Num t) => Vector t 3 -> Vector t 3 -> Vector t 3
infixl 7 ×


module Numeric.Matrix
class MatrixCalculus t (n :: Nat) (m :: Nat)

-- | Transpose Mat
transpose :: (MatrixCalculus t n m, MatrixCalculus t m n, PrimBytes (Matrix t m n)) => Matrix t n m -> Matrix t m n
class SquareMatrixCalculus t (n :: Nat)

-- | Mat with 1 on diagonal and 0 elsewhere
eye :: SquareMatrixCalculus t n => Matrix t n n

-- | Put the same value on the Mat diagonal, 0 otherwise
diag :: SquareMatrixCalculus t n => Scalar t -> Matrix t n n

-- | Determinant of Mat
det :: SquareMatrixCalculus t n => Matrix t n n -> t

-- | Sum of diagonal elements
trace :: SquareMatrixCalculus t n => Matrix t n n -> Scalar t
class MatrixInverse t (n :: Nat)

-- | Matrix inverse
inverse :: MatrixInverse t n => DataFrame t '[n, n] -> DataFrame t '[n, n]

-- | Alias for DataFrames of rank 2
type Matrix t (n :: Nat) (m :: Nat) = DataFrame t '[n, m]
type Mat22f = Matrix Float 2 2
type Mat23f = Matrix Float 2 3
type Mat24f = Matrix Float 2 4
type Mat32f = Matrix Float 3 2
type Mat33f = Matrix Float 3 3
type Mat34f = Matrix Float 3 4
type Mat42f = Matrix Float 4 2
type Mat43f = Matrix Float 4 3
type Mat44f = Matrix Float 4 4

-- | Compose a 2x2D matrix
mat22 :: (PrimBytes (Vector t 2), PrimBytes (Matrix t 2 2)) => Vector t 2 -> Vector t 2 -> Matrix t 2 2

-- | Compose a 3x3D matrix
mat33 :: (PrimBytes t, PrimBytes (Vector t 3), PrimBytes (Matrix t 3 3)) => Vector t 3 -> Vector t 3 -> Vector t 3 -> Matrix t 3 3

-- | Compose a 4x4D matrix
mat44 :: forall (t :: Type). (PrimBytes t, PrimBytes (Vector t (4 :: Nat)), PrimBytes (Matrix t (4 :: Nat) (4 :: Nat))) => Vector t (4 :: Nat) -> Vector t (4 :: Nat) -> Vector t (4 :: Nat) -> Vector t (4 :: Nat) -> Matrix t (4 :: Nat) (4 :: Nat)

-- | Tensor contraction. In particular: 1. matrix-matrix product 2.
--   matrix-vector or vector-matrix product 3. dot product of two vectors.
(%*) :: (ConcatList as bs (as ++ bs), Contraction t as bs asbs, KnownDim m, PrimBytes (DataFrame t (as +: m)), PrimBytes (DataFrame t (m :+ bs)), PrimBytes (DataFrame t (as ++ bs))) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t (as ++ bs)
infixl 7 %*


module Numeric.DataFrame

-- | Keep data in a primitive data frame and maintain information about
--   Dimensions in the type-system

-- | Allow all numeric operations depending on element type
type NumericFrame t ds = (CommonOpFrame t ds, NumericVariantFrame t ds)

-- | Allow floating-point operations on data frames
type FPFRame t ds = (Fractional (DataFrame t ds), Floating (DataFrame t ds))

-- | Allow some integer-like operations on data frames
type IntegralFrame t (ds :: [Nat]) = Bounded (DataFrame t ds)

-- | Allow all common operations on data frames
type CommonOpFrame t ds = (Show (DataFrame t ds), Eq (DataFrame t ds), Ord (DataFrame t ds), Num (DataFrame t ds), ElementWise (Idx ds) t (DataFrame t ds), PrimBytes (DataFrame t ds), ArrayInstanceInference t ds, KnownDims ds, FiniteList ds, Dimensions ds)

-- | Operations on DataFrames as is an element dimensionality bs is an
--   indexing dimensionality t is an underlying data type (i.e. Float, Int,
--   Double)
class (ConcatList as bs asbs, Dimensions as, Dimensions bs, Dimensions asbs) => SubSpace (t :: Type) (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) | asbs as -> bs, asbs bs -> as, as bs -> asbs

-- | Get an element
(!.) :: SubSpace t as bs asbs => Idx bs -> DataFrame t asbs -> DataFrame t as

-- | Set a new value to an element
update :: SubSpace t as bs asbs => Idx bs -> DataFrame t as -> DataFrame t asbs -> DataFrame t asbs

-- | Map a function over each element of DataFrame
ewmap :: forall s (as' :: [Nat]) (asbs' :: [Nat]). (SubSpace t as bs asbs, SubSpace s as' bs asbs') => (DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs

-- | Map a function over each element with its index of DataFrame
iwmap :: forall s (as' :: [Nat]) (asbs' :: [Nat]). (SubSpace t as bs asbs, SubSpace s as' bs asbs') => (Idx bs -> DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs

-- | Generate a DataFrame by repeating an element
ewgen :: SubSpace t as bs asbs => DataFrame t as -> DataFrame t asbs

-- | Generate a DataFrame by iterating a function (index -&gt; element)
iwgen :: SubSpace t as bs asbs => (Idx bs -> DataFrame t as) -> DataFrame t asbs

-- | Left-associative fold of a DataFrame. The fold is strict, so
--   accumulater is evaluated to WHNF; but you'd better make sure that the
--   function is strict enough to not produce memory leaks deeply inside
--   the result data type.
ewfoldl :: SubSpace t as bs asbs => (b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b

-- | Left-associative fold of a DataFrame with an index The fold is strict,
--   so accumulater is evaluated to WHNF; but you'd better make sure that
--   the function is strict enough to not produce memory leaks deeply
--   inside the result data type.
iwfoldl :: SubSpace t as bs asbs => (Idx bs -> b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b

-- | Right-associative fold of a DataFrame The fold is strict, so
--   accumulater is evaluated to WHNF; but you'd better make sure that the
--   function is strict enough to not produce memory leaks deeply inside
--   the result data type.
ewfoldr :: SubSpace t as bs asbs => (DataFrame t as -> b -> b) -> b -> DataFrame t asbs -> b

-- | Right-associative fold of a DataFrame with an index The fold is
--   strict, so accumulater is evaluated to WHNF; but you'd better make
--   sure that the function is strict enough to not produce memory leaks
--   deeply inside the result data type.
iwfoldr :: SubSpace t as bs asbs => (Idx bs -> DataFrame t as -> b -> b) -> b -> DataFrame t asbs -> b

-- | Apply an applicative functor on each element (Lens-like traversal)
elementWise :: forall s (as' :: [Nat]) (asbs' :: [Nat]) f. (SubSpace t as bs asbs, Applicative f, SubSpace s as' bs asbs') => (DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs)

-- | Apply an applicative functor on each element with its index (Lens-like
--   indexed traversal)
indexWise :: forall s (as' :: [Nat]) (asbs' :: [Nat]) f. (SubSpace t as bs asbs, Applicative f, SubSpace s as' bs asbs') => (Idx bs -> DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs)

-- | Index an element (reverse of !.)
(!) :: SubSpace t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) => DataFrame t asbs -> Idx bs -> DataFrame t as
infixl 4 !

-- | Apply a functor over a single element (simple lens)
element :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) f. (SubSpace t as bs asbs, Applicative f) => Idx bs -> (DataFrame t as -> f (DataFrame t as)) -> DataFrame t asbs -> f (DataFrame t asbs)
ewfoldMap :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) m. (Monoid m, SubSpace t as bs asbs) => (DataFrame t as -> m) -> DataFrame t asbs -> m
iwfoldMap :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) m. (Monoid m, SubSpace t as bs asbs) => (Idx bs -> DataFrame t as -> m) -> DataFrame t asbs -> m

-- | Zip two spaces on a specified subspace element-wise (without index)
ewzip :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) s (as' :: [Nat]) (asbs' :: [Nat]) r (as'' :: [Nat]) (asbs'' :: [Nat]). (SubSpace t as bs asbs, SubSpace s as' bs asbs', SubSpace r as'' bs asbs'') => (DataFrame t as -> DataFrame s as' -> DataFrame r as'') -> DataFrame t asbs -> DataFrame s asbs' -> DataFrame r asbs''

-- | Zip two spaces on a specified subspace index-wise (with index)
iwzip :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) s (as' :: [Nat]) (asbs' :: [Nat]) r (as'' :: [Nat]) (asbs'' :: [Nat]). (SubSpace t as bs asbs, SubSpace s as' bs asbs', SubSpace r as'' bs asbs'') => (Idx bs -> DataFrame t as -> DataFrame s as' -> DataFrame r as'') -> DataFrame t asbs -> DataFrame s asbs' -> DataFrame r asbs''
class ConcatList as bs asbs => Contraction (t :: Type) (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) | asbs as -> bs, asbs bs -> as, as bs -> asbs

-- | Generalization of a matrix product: take scalar product over one
--   dimension and, thus, concatenate other dimesnions
contract :: (Contraction t as bs asbs, KnownDim m, PrimBytes (DataFrame t (as +: m)), PrimBytes (DataFrame t (m :+ bs)), PrimBytes (DataFrame t asbs)) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t asbs

-- | Tensor contraction. In particular: 1. matrix-matrix product 2.
--   matrix-vector or vector-matrix product 3. dot product of two vectors.
(%*) :: (ConcatList as bs (as ++ bs), Contraction t as bs asbs, KnownDim m, PrimBytes (DataFrame t (as +: m)), PrimBytes (DataFrame t (m :+ bs)), PrimBytes (DataFrame t (as ++ bs))) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t (as ++ bs)
infixl 7 %*

-- | Evidence for PrimBytes class
type PrimBytesEvidence t (ds :: [Nat]) = Evidence (PrimBytes (DataFrame t ds))
inferPrimBytes :: forall t (ds :: [Nat]). (ArrayInstanceInference t ds, Dimensions ds) => PrimBytesEvidence t ds

-- | Evidence for ElementWise class
type ElementWiseEvidence t (ds :: [Nat]) = Evidence (ElementWise (Idx ds) t (DataFrame t ds))
inferElementWise :: forall t (ds :: [Nat]). (ArrayInstanceInference t ds, Dimensions ds) => ElementWiseEvidence t ds

-- | Allow all common operations on available data frames
type NumericFrameEvidence t (ds :: [Nat]) = Evidence (NumericFrame t ds)
inferNumericFrame :: forall t (ds :: [Nat]). (ArrayInstanceInference t ds, Dimensions ds) => NumericFrameEvidence t ds

-- | Append one DataFrame to another, adding up their last dimensionality
(<:>) :: forall (n :: Nat) (m :: Nat) (npm :: Nat) (ds :: [Nat]) (t :: Type). (PrimBytes (DataFrame t (ds +: n)), PrimBytes (DataFrame t (ds +: m)), PrimBytes (DataFrame t (ds +: npm)), npm ~ (n + m), n ~ (npm - m), m ~ (npm - n)) => DataFrame t (ds +: n) -> DataFrame t (ds +: m) -> DataFrame t (ds +: npm)
infixl 5 <:>

-- | Append one DataFrame to another, adding up their last dimensionality
(<::>) :: forall (ds :: [Nat]) (t :: Type). (PrimBytes (DataFrame t ds), PrimBytes (DataFrame t ds), PrimBytes (DataFrame t (ds +: 2 :: [Nat]))) => DataFrame t ds -> DataFrame t ds -> DataFrame t (ds +: 2 :: [Nat])
infixl 5 <::>

-- | Append one DataFrame to another, adding up their last dimensionality
(<+:>) :: forall (ds :: [Nat]) (n :: Nat) (m :: Nat) (t :: Type). (PrimBytes (DataFrame t (ds +: n)), PrimBytes (DataFrame t ds), PrimBytes (DataFrame t (ds +: m)), m ~ (n + 1)) => DataFrame t (ds +: n) -> DataFrame t ds -> DataFrame t (ds +: m)
infixl 5 <+:>

-- | Input must be parametrized by [Nat] to make sure every element in the
--   input list has the same dimensionality. Output is in [XNat], because
--   the last dimension is unknown at compile time
fromList :: forall ns t xns xnsm. (ns ~ AsDims xns, xnsm ~ (xns +: XN 2), PrimBytes (DataFrame t ns), Dimensions ns, ArrayInstanceInference t ns) => [DataFrame t ns] -> DataFrame t (xns +: XN 2)

-- | Implement function <a>toList</a>. We need to create a dedicated type
--   class for this to make it polymorphic over kind k (Nat <a>-</a> XNat).
class DataFrameToList t z (ds :: [k])

-- | Unwrap the last dimension of a DataFrame into a list of smaller frames
toList :: DataFrameToList t z ds => DataFrame t (ds +: z) -> [DataFrame t ds]

-- | Broadcast scalar value onto a whole data frame
fromScalar :: ElementWise (Idx ds) t (DataFrame t ds) => Scalar t -> DataFrame t ds

-- | Access elements. i is an index type x is an element t is a container
--   type
class ElementWise i x t | t -> x i

-- | A singleton type used to prove that the given Array family instance
--   has a known instance
type ArrayInstanceEvidence t (ds :: [Nat]) = Evidence (ArrayInstanceInference t ds)

-- | Keep information about the instance behind Array family
data ArrayInstance t (ds :: [Nat])
AIScalar :: ArrayInstance t
AIArrayF :: ArrayInstance t
AIArrayD :: ArrayInstance t
AIArrayI :: ArrayInstance t
AIArrayI8 :: ArrayInstance t
AIArrayI16 :: ArrayInstance t
AIArrayI32 :: ArrayInstance t
AIArrayI64 :: ArrayInstance t
AIArrayW :: ArrayInstance t
AIArrayW8 :: ArrayInstance t
AIArrayW16 :: ArrayInstance t
AIArrayW32 :: ArrayInstance t
AIArrayW64 :: ArrayInstance t
AIFloatX2 :: ArrayInstance t
AIFloatX3 :: ArrayInstance t
AIFloatX4 :: ArrayInstance t
getArrayInstance :: forall t (ds :: [Nat]). ArrayInstanceInference t ds => ArrayInstance t ds

-- | Given element type instance and proper dimension list, infer a
--   corresponding array instance
inferArrayInstance :: forall t ds. (FiniteList ds, KnownDims ds, ElemTypeInference t) => ArrayInstanceEvidence t ds
class ArraySizeInference ds

-- | Pattern match agains result to get actual array dimensionality
arraySizeInstance :: ArraySizeInference ds => ArraySize ds
inferSnocArrayInstance :: (ArraySizeInference ds, ElemTypeInference t, KnownDim z) => p t ds -> q z -> ArrayInstanceEvidence t (ds +: z)
inferConsArrayInstance :: (ArraySizeInference ds, ElemTypeInference t, KnownDim z) => q z -> p t ds -> ArrayInstanceEvidence t (z :+ ds)
inferInitArrayInstance :: (ArraySizeInference ds, ElemTypeInference t) => p t ds -> ArrayInstanceEvidence t (Init ds)

-- | Keep information about the array dimensionality
data ArraySize (ds :: [Nat])
ASScalar :: ArraySize
ASX2 :: ArraySize
ASX3 :: ArraySize
ASX4 :: ArraySize
ASXN :: ArraySize
ASArray :: ArraySize
class ElemTypeInference t

-- | Pattern match against result to get specific element type
elemTypeInstance :: ElemTypeInference t => ElemType t

-- | Keep information about the element type instance
data ElemType t
ETFloat :: ElemType t
ETDouble :: ElemType t
ETInt :: ElemType t
ETInt8 :: ElemType t
ETInt16 :: ElemType t
ETInt32 :: ElemType t
ETInt64 :: ElemType t
ETWord :: ElemType t
ETWord8 :: ElemType t
ETWord16 :: ElemType t
ETWord32 :: ElemType t
ETWord64 :: ElemType t