content: {-# LANGUAGE PolyKinds   #-}
  {-# LANGUAGE BangPatterns #-}
  {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE TypeFamilies #-}
  
  module Numerical.Array where
  
  --import Numerical.Array.Shape
  
  --data  MArray  world rep lay (view:: Locality) sh elem
  
  
  
  
  
  
  {-
  lets do just IO and not ST for now?
  or bite the primstate bullet now?
  -}
  
  --data family Array world rep lay (view:: Locality) sh elm
  
  
  {-
  only Row and Column Major have  dense formats that are unique across ALL
  possible ranks, not so simple for others. Make different data instances per formats
  
  
  
  
  
  -}
  --class Array  where
  
  -----------
  -- | for now locality is a closed type, may change going forward
  -- also should it be in a different module like shape or layout?
  
  
  
  {-
  theres several points in the design space of array apis that are nice, but none quite right
  
  Vector is probably the closest
  pros:
    which has nice pure vs mutable apis
    simple interface
  cons:
    its really designed for Int indexing
    assumes every pure Vector is internally derived from an imperative one
      (this is reflected  in where the thaw/freeze)
  
  so there needs to be an Array class, an MArray class,
  
  and the Thawing / Freezing needs to be in a seperate PhasedArray class!
  why? Because we can't assume that pure/mutable arrays are the fundamental data type!
  
  -}
  
  
  {-
  maybe do
       data Locality = Contiguous | Strided
  
  For now lets assume that the concrete (rather than delayed) arrays
  have a regular structure when strided. (rather than nonuniform gaps)
  -}
  {-
  rep = storable, unboxed, boxed, delay, etc
  
  lay = row major, column major, morton z, morton w (flipped n),
    --- this  ignores symmetry  and hermitian being properties as well as packed layouts
    --- also need to have a good sparse story
      --- as currently done, most don't really make sense for != rank-2 arrays,
  
  -- rowMajor is a foldR, columnMajor is a foldL  over the shape ices
  
  -- Repa and accelerate use a Snoc List so that Row major fuses well for row major
  
  sh= rank / shape, ie matrix or vector, or some  higher tensor thingy
  lets borrow from  repa/ accelea
  
  
  mode= need to have a notion of runnable worlds,
  based on "backend" chosen, eg CBlasish, DPH, Repa, LLVM, Free (get the shallow/ deep ast)
  
  view =
      Origin, Slice, and Diced, I might make this a fixed universe for now
      Lets not distinguish whether a contiguous array is the original or derived for now
      doesn't seem to be a meaningful difference and would make type inference crap / not bijective
      Note that this does mean that accidental space leaks may happen
  
      that suggests (but not for now) having a notion of origin / derived
      that would allow elimiting space leaks. But lets not do that for now
  
  -}
  
  {-
  
  uncheckedReshape :: Array wld rep lay
  
  
  -}
  
  
  