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


-- | Arbitrary sized type-safe grids with useful combinators
@package grids
@version 0.3.0.0

module Data.Grid.Internal.Coord

-- | The index type for <tt>Grid</tt>s.
newtype Coord (dims :: [Nat])
Coord :: [Int] -> Coord
[unCoord] :: Coord -> [Int]

-- | Safely construct a <a>Coord</a> for a given grid size, checking that
--   all indexes are in range
--   
--   <pre>
--   λ&gt; coord @[3, 3] [1, 2]
--   Just [1, 2]
--   
--   λ&gt; coord @[3, 3] [3, 3]
--   Nothing
--   
--   λ&gt; coord @[3, 3] [1, 2, 3]
--   Nothing
--   </pre>
coord :: forall dims. SingI dims => [Int] -> Maybe (Coord dims)

-- | Get the first index from a <a>Coord</a>
unconsC :: Coord (n : ns) -> (Int, Coord ns)

-- | Append two <a>Coord</a>s
appendC :: Coord ns -> Coord ms -> Coord (ns ++ ms)
pattern (:#) :: Int -> Coord ns -> Coord (n : ns)
highestIndex :: forall n. KnownNat n => Int
clamp :: Int -> Int -> Int -> Int
clampCoord :: forall dims. SingI dims => Coord dims -> Coord dims
wrapCoord :: forall dims. SingI dims => Coord dims -> Coord dims

-- | Get the total size of a <tt>Grid</tt> of the given dimensions
--   
--   <pre>
--   gridSize @'[2, 2] == 4
--   </pre>
gridSize :: forall (dims :: [Nat]). SingI dims => Int
coerceCoordDims :: Coord ns -> Coord ms
coordInBounds :: forall ns. SingI ns => Coord ns -> Bool
instance GHC.Classes.Eq (Data.Grid.Internal.Coord.Coord dims)
instance GHC.Exts.IsList (Data.Grid.Internal.Coord.Coord dims)
instance GHC.Show.Show (Data.Grid.Internal.Coord.Coord dims)
instance GHC.Enum.Enum (Data.Grid.Internal.Coord.Coord ns) => GHC.Num.Num (Data.Grid.Internal.Coord.Coord ns)
instance GHC.Enum.Bounded (Data.Grid.Internal.Coord.Coord '[])
instance (GHC.TypeNats.KnownNat n, GHC.Enum.Bounded (Data.Grid.Internal.Coord.Coord ns)) => GHC.Enum.Bounded (Data.Grid.Internal.Coord.Coord (n : ns))
instance GHC.TypeNats.KnownNat n => GHC.Enum.Enum (Data.Grid.Internal.Coord.Coord '[n])
instance (GHC.TypeNats.KnownNat x, GHC.TypeNats.KnownNat y, Data.Singletons.Internal.SingI rest, GHC.Enum.Bounded (Data.Grid.Internal.Coord.Coord rest), GHC.Enum.Enum (Data.Grid.Internal.Coord.Coord (y : rest))) => GHC.Enum.Enum (Data.Grid.Internal.Coord.Coord (x : y : rest))

module Data.Grid.Internal.Errors
type family (b :: Bool) ?! (e :: ErrorMessage) :: Constraint
infixr 1 ?!

module Data.Grid.Internal.NestedLists
type family AllC (c :: x -> Constraint) (ts :: [x]) :: Constraint

-- | Computes the level of nesting requried to represent a given grid
--   dimensionality as a nested list
--   
--   <pre>
--   NestedLists [2, 3] Int == [[Int]]
--   NestedLists [2, 3, 4] Int == [[[Int]]]
--   </pre>
type family NestedLists (dims :: [Nat]) a
chunkVector :: forall a. Int -> Vector a -> [Vector a]

-- | Represents valid dimensionalities. All non empty lists of Nats have an
--   instance
class (AllC KnownNat dims, SingI dims, Enum (Coord dims), Bounded (Coord dims)) => Dimensions (dims :: [Nat])
nestLists :: Dimensions dims => Proxy dims -> Vector a -> NestedLists dims a
unNestLists :: Dimensions dims => Proxy dims -> NestedLists dims a -> [a]
instance GHC.TypeNats.KnownNat x => Data.Grid.Internal.NestedLists.Dimensions '[x]
instance (GHC.TypeNats.KnownNat x, GHC.Enum.Bounded (Data.Grid.Internal.Coord.Coord xs), Data.Singletons.Internal.SingI xs, Data.Grid.Internal.NestedLists.Dimensions (y : xs)) => Data.Grid.Internal.NestedLists.Dimensions (x : y : xs)

module Data.Grid.Internal.Pretty
class PrettyList l
prettyList :: PrettyList l => l -> String
instance GHC.Show.Show a => Data.Grid.Internal.Pretty.PrettyList [a]
instance GHC.Show.Show a => Data.Grid.Internal.Pretty.PrettyList [[a]]
instance GHC.Show.Show a => Data.Grid.Internal.Pretty.PrettyList [[[a]]]

module Data.Grid.Internal.Grid

-- | An grid of arbitrary dimensions.
--   
--   e.g. a <tt>Grid [2, 3] Int</tt> might look like:
--   
--   <pre>
--   generate id :: Grid [2, 3] Int
--   fromNestedLists [[0,1,2],
--                    [3,4,5]]
--   </pre>
newtype Grid (dims :: [Nat]) a
Grid :: Vector a -> Grid a
[toVector] :: Grid a -> Vector a

-- | Represents valid dimensionalities. All non empty lists of Nats have an
--   instance
class (AllC KnownNat dims, SingI dims, Enum (Coord dims), Bounded (Coord dims)) => Dimensions (dims :: [Nat])
nestLists :: Dimensions dims => Proxy dims -> Vector a -> NestedLists dims a
unNestLists :: Dimensions dims => Proxy dims -> NestedLists dims a -> [a]

-- | The index type for <tt>Grid</tt>s.
data Coord (dims :: [Nat])

-- | Computes the level of nesting requried to represent a given grid
--   dimensionality as a nested list
--   
--   <pre>
--   NestedLists [2, 3] Int == [[Int]]
--   NestedLists [2, 3, 4] Int == [[[Int]]]
--   </pre>
type family NestedLists (dims :: [Nat]) a

-- | Build a grid by selecting an element for each element
generate :: forall dims a. SingI dims => (Int -> a) -> Grid dims a

-- | Turn a grid into a nested list structure. List nesting increases for
--   each dimension
--   
--   <pre>
--   toNestedLists (G.generate id :: Grid [2, 3] Int)
--   [[0,1,2],[3,4,5]]
--   </pre>
toNestedLists :: forall dims a. Dimensions dims => Grid dims a -> NestedLists dims a

-- | Turn a nested list structure into a Grid if the list is well formed.
--   Required list nesting increases for each dimension
--   
--   <pre>
--   fromNestedLists [[0,1,2],[3,4,5]] :: Maybe (Grid [2, 3] Int)
--   Just (Grid [[0,1,2],[3,4,5]])
--   fromNestedLists [[0],[1,2]] :: Maybe (Grid [2, 3] Int)
--   Nothing
--   </pre>
fromNestedLists :: forall dims a. Dimensions dims => NestedLists dims a -> Maybe (Grid dims a)

-- | Partial variant of <a>fromNestedLists</a> which errors on malformed
--   input
fromNestedLists' :: forall dims a. Dimensions dims => NestedLists dims a -> Grid dims a

-- | Convert a list into a Grid or fail if not provided the correct number
--   of elements
--   
--   <pre>
--   G.fromList [0, 1, 2, 3, 4, 5] :: Maybe (Grid [2, 3] Int)
--   Just (Grid [[0,1,2],[3,4,5]])
--   G.fromList [0, 1, 2, 3] :: Maybe (Grid [2, 3] Int)
--   Nothing
--   </pre>
fromList :: forall dims a. SingI dims => [a] -> Maybe (Grid dims a)

-- | Partial variant of <a>fromList</a> which errors on malformed input
fromList' :: forall dims a. SingI dims => [a] -> Grid dims a

-- | Update elements of a grid
(//) :: forall dims a. Enum (Coord dims) => Grid dims a -> [(Coord dims, a)] -> Grid dims a
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Grid.Internal.Grid.Grid dims a)
instance Data.Traversable.Traversable (Data.Grid.Internal.Grid.Grid dims)
instance Data.Foldable.Foldable (Data.Grid.Internal.Grid.Grid dims)
instance GHC.Base.Functor (Data.Grid.Internal.Grid.Grid dims)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Grid.Internal.Grid.Grid dims a)
instance (Data.Grid.Internal.Pretty.PrettyList (Data.Grid.Internal.NestedLists.NestedLists dims a), Data.Grid.Internal.NestedLists.Dimensions dims, GHC.Show.Show (Data.Grid.Internal.NestedLists.NestedLists dims a)) => GHC.Show.Show (Data.Grid.Internal.Grid.Grid dims a)
instance (Data.Grid.Internal.NestedLists.Dimensions dims, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Data.Grid.Internal.Grid.Grid dims a)
instance (Data.Grid.Internal.NestedLists.Dimensions dims, GHC.Base.Monoid a) => GHC.Base.Monoid (Data.Grid.Internal.Grid.Grid dims a)
instance Data.Grid.Internal.NestedLists.Dimensions dims => GHC.Base.Applicative (Data.Grid.Internal.Grid.Grid dims)
instance Data.Grid.Internal.NestedLists.Dimensions dims => Data.Distributive.Distributive (Data.Grid.Internal.Grid.Grid dims)
instance Data.Grid.Internal.NestedLists.Dimensions dims => Data.Functor.Rep.Representable (Data.Grid.Internal.Grid.Grid dims)
instance (GHC.Num.Num n, Data.Grid.Internal.NestedLists.Dimensions dims) => GHC.Num.Num (Data.Grid.Internal.Grid.Grid dims n)

module Data.Grid.Internal.Nest

-- | The inverse of <a>splitGrid</a>, joinGrid will nest a grid from: &gt;
--   Grid outer (Grid inner a) -&gt; Grid (outer ++ inner) a
--   
--   For example, you can nest a simple 3x3 from smaller [3] grids as
--   follows:
--   
--   <pre>
--   joinGrid (myGrid :: Grid [3] (Grid [3] a)) :: Grid '[3, 3] a
--   </pre>
joinGrid :: Grid dims (Grid ns a) -> Grid (dims ++ ns) a

-- | The inverse of <a>joinGrid</a>, splitGrid <tt>outerDims </tt>innerDims
--   will un-nest a grid from: &gt; Grid (outer ++ inner) a -&gt; Grid
--   outer (Grid inner a)
--   
--   For example, you can unnest a simple 3x3 as follows:
--   
--   <pre>
--   splitGrid @'[3] @'[3] myGrid :: Grid '[3] (Grid [3] a)
--   </pre>
splitGrid :: forall outer inner a from. (from ~ (outer ++ inner), Dimensions from, Dimensions inner, Dimensions outer, NestedLists from a ~ NestedLists outer (NestedLists inner a)) => Grid from a -> Grid outer (Grid inner a)

module Data.Grid.Internal.Lens
type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t
type Lens' s a = Lens s s a a
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b

-- | Focus an element of a <a>Grid</a> given its <a>Coord</a>
cell :: forall ind dims a. Dimensions dims => Coord dims -> Lens' (Grid dims a) a

module Data.Grid.Internal.Identity

module Data.Grid.Internal.Convolution
criticalError :: a

-- | Perform a computation based on the context surrounding a cell Good for
--   doing things like Linear Image Filters (e.g. gaussian blur) or
--   simulating Cellular Automata (e.g. Conway's game of life)
--   
--   This function accepts a function which indicates what to do with
--   'out-of-bounds' indexes, <a>clampWindow</a>, <a>wrapWindow</a> and
--   <a>safeWindow</a> are examples.
--   
--   It also acccepts a transformation function which operates over the
--   functor created by the first parameter and collapses it down to a new
--   value for the cell at that position.
--   
--   This function is best used with Type Applications to denote the
--   desired window size; the Grid passed to the given function contains
--   the current cell (in the middle) and all the surrounding cells.
--   
--   Here's an example of computing the average of all neighbouring cells,
--   repeating values at the edge of the grid when indexes are out of
--   bounds (using <a>clampWindow</a>)
--   
--   <pre>
--   gaussian :: (Dimensions dims) =&gt; Grid dims Double -&gt; Grid dims Double
--   gaussian = autoConvolute clampWindow avg
--    where
--     avg :: Grid '[3, 3] Double -&gt; Double
--     avg g = sum g / fromIntegral (length g)
--   </pre>
autoConvolute :: forall window dims f a b. (Dimensions dims, Dimensions window, Functor f, Neighboring window) => (Grid window (Coord dims) -> f (Coord dims)) -> (f a -> b) -> Grid dims a -> Grid dims b

-- | This is a fully generic version of <a>autoConvolute</a> which allows
--   the user to provide a function which builds a context from the current
--   coord, then provides a collapsing function over the same functor.
convolute :: forall dims f a b. (Functor f, Dimensions dims) => (Coord dims -> f (Coord dims)) -> (f a -> b) -> Grid dims a -> Grid dims b

-- | Given a coordinate generate a grid of size <a>window</a> filled with
--   coordinates surrounding the given coord. Mostly used internally
window :: forall window dims. (Neighboring window, Dimensions window) => Coord dims -> Grid window (Coord dims)
class Neighboring dims
neighbors :: Neighboring dims => Grid dims (Coord dims)
neighboring :: (Dimensions dims, Neighboring dims) => Coord dims -> Grid dims (Coord dims)

-- | Use with <a>autoConvolute</a>; Clamp out-of-bounds coordinates to the
--   nearest in-bounds coord.
clampWindow :: Dimensions dims => Grid window (Coord dims) -> Grid window (Coord dims)

-- | Use with <a>autoConvolute</a>; Wrap out-of-bounds coordinates pac-man
--   style to the other side of the grid
wrapWindow :: Dimensions dims => Grid window (Coord dims) -> Grid window (Coord dims)

-- | Use with <a>autoConvolute</a>; Out of bounds coords become
--   <a>Nothing</a>
safeWindow :: Dimensions dims => Grid window (Coord dims) -> Compose (Grid window) Maybe (Coord dims)
instance GHC.TypeNats.KnownNat n => Data.Grid.Internal.Convolution.Neighboring '[n]
instance (GHC.TypeNats.KnownNat n, Data.Grid.Internal.Convolution.Neighboring ns) => Data.Grid.Internal.Convolution.Neighboring (n : ns)

module Data.Grid.Internal.Transpose
type family Permuted (key :: [Nat]) (from :: [Nat]) :: [Nat]
type ValidPermutation key from = (Sort key == EnumFromTo 0 (Length from - 1)) ?! (Text "Malformed permutation hint: " :<>: ShowType key :$$: Text "When permuting matrix of size: " :<>: ShowType from :$$: Text "Key must be a permutation of " :<>: ShowType (EnumFromTo 0 (Length from - 1)) :$$: Text "e.g. the identity permutation for 2x2 is @[0, 1]" :$$: Text "e.g. matrix transpose for 2x2 is @[1, 0]")

-- | Permute dimensions of a <a>Grid</a>. This is similar to MatLab's
--   permute function
--   
--   <a>permute</a> requires a type application containing a permutation
--   pattern; The pattern is a re-ordering of the list <tt>[0..n]</tt>
--   which represents the new dimension order. For example the permutation
--   pattern <tt>[1, 2, 0]</tt> when applied to the dimensions <tt>[4, 5,
--   6]</tt> results in the dimensions <tt>[5, 6, 4]</tt>.
--   
--   For 2 dimensional matrixes, a permutation using <tt>[1, 0]</tt> is
--   simply a matrix <a>transpose</a>
--   
--   <pre>
--   λ&gt; small
--   fromNestedLists
--     [[0,1,2]
--     ,[3,4,5]
--     ,[6,7,8]]
--   
--   λ&gt; permute @[1, 0] small
--   fromNestedLists
--     [[0,3,6]
--     ,[1,4,7]
--     ,[2,5,8]]
--   </pre>
permute :: forall (key :: [Nat]) from a invertedKey. (SingI invertedKey, invertedKey ~ InvertKey (EnumFromTo 0 (Length from - 1)) key, ValidPermutation key from, Dimensions from, Dimensions (Permuted key from)) => Grid from a -> Grid (Permuted key from) a

-- | Permute the dimensions of a coordinate according to a permutation
--   pattern. see <a>permute</a> regarding permutation patterns
permuteCoord :: forall (key :: [Nat]) to from. SingI key => Coord from -> Coord to

-- | Transpose a 2 dimensional matrix. Equivalent to:
--   
--   <pre>
--   permute @[1, 0]
--   </pre>
transpose :: (KnownNat x, KnownNat y) => Grid '[x, y] a -> Grid '[y, x] a

-- | Get the inverse of a permutation pattern, used internally
type family InvertKey ref key :: [Nat]

module Data.Grid

-- | An grid of arbitrary dimensions.
--   
--   e.g. a <tt>Grid [2, 3] Int</tt> might look like:
--   
--   <pre>
--   generate id :: Grid [2, 3] Int
--   fromNestedLists [[0,1,2],
--                    [3,4,5]]
--   </pre>
newtype Grid (dims :: [Nat]) a
Grid :: Vector a -> Grid a
[toVector] :: Grid a -> Vector a

-- | Build a grid by selecting an element for each element
generate :: forall dims a. SingI dims => (Int -> a) -> Grid dims a

-- | <pre>
--   <a>fmap</a> f . <a>tabulate</a> ≡ <a>tabulate</a> . <a>fmap</a> f
--   </pre>
--   
--   If no definition is provided, this will default to <a>gtabulate</a>.
tabulate :: Representable f => (Rep f -> a) -> f a

-- | Turn a nested list structure into a Grid if the list is well formed.
--   Required list nesting increases for each dimension
--   
--   <pre>
--   fromNestedLists [[0,1,2],[3,4,5]] :: Maybe (Grid [2, 3] Int)
--   Just (Grid [[0,1,2],[3,4,5]])
--   fromNestedLists [[0],[1,2]] :: Maybe (Grid [2, 3] Int)
--   Nothing
--   </pre>
fromNestedLists :: forall dims a. Dimensions dims => NestedLists dims a -> Maybe (Grid dims a)

-- | Partial variant of <a>fromNestedLists</a> which errors on malformed
--   input
fromNestedLists' :: forall dims a. Dimensions dims => NestedLists dims a -> Grid dims a

-- | Convert a list into a Grid or fail if not provided the correct number
--   of elements
--   
--   <pre>
--   G.fromList [0, 1, 2, 3, 4, 5] :: Maybe (Grid [2, 3] Int)
--   Just (Grid [[0,1,2],[3,4,5]])
--   G.fromList [0, 1, 2, 3] :: Maybe (Grid [2, 3] Int)
--   Nothing
--   </pre>
fromList :: forall dims a. SingI dims => [a] -> Maybe (Grid dims a)

-- | Partial variant of <a>fromList</a> which errors on malformed input
fromList' :: forall dims a. SingI dims => [a] -> Grid dims a

-- | Turn a grid into a nested list structure. List nesting increases for
--   each dimension
--   
--   <pre>
--   toNestedLists (G.generate id :: Grid [2, 3] Int)
--   [[0,1,2],[3,4,5]]
--   </pre>
toNestedLists :: forall dims a. Dimensions dims => Grid dims a -> NestedLists dims a

-- | The index type for <tt>Grid</tt>s.
newtype Coord (dims :: [Nat])
Coord :: [Int] -> Coord
[unCoord] :: Coord -> [Int]

-- | Safely construct a <a>Coord</a> for a given grid size, checking that
--   all indexes are in range
--   
--   <pre>
--   λ&gt; coord @[3, 3] [1, 2]
--   Just [1, 2]
--   
--   λ&gt; coord @[3, 3] [3, 3]
--   Nothing
--   
--   λ&gt; coord @[3, 3] [1, 2, 3]
--   Nothing
--   </pre>
coord :: forall dims. SingI dims => [Int] -> Maybe (Coord dims)

-- | Get the first index from a <a>Coord</a>
unconsC :: Coord (n : ns) -> (Int, Coord ns)

-- | Append two <a>Coord</a>s
appendC :: Coord ns -> Coord ms -> Coord (ns ++ ms)

-- | If no definition is provided, this will default to <a>gindex</a>.
index :: Representable f => f a -> Rep f -> a

-- | Update elements of a grid
(//) :: forall dims a. Enum (Coord dims) => Grid dims a -> [(Coord dims, a)] -> Grid dims a

-- | Focus an element of a <a>Grid</a> given its <a>Coord</a>
cell :: forall ind dims a. Dimensions dims => Coord dims -> Lens' (Grid dims a) a

-- | Perform a computation based on the context surrounding a cell Good for
--   doing things like Linear Image Filters (e.g. gaussian blur) or
--   simulating Cellular Automata (e.g. Conway's game of life)
--   
--   This function accepts a function which indicates what to do with
--   'out-of-bounds' indexes, <a>clampWindow</a>, <a>wrapWindow</a> and
--   <a>safeWindow</a> are examples.
--   
--   It also acccepts a transformation function which operates over the
--   functor created by the first parameter and collapses it down to a new
--   value for the cell at that position.
--   
--   This function is best used with Type Applications to denote the
--   desired window size; the Grid passed to the given function contains
--   the current cell (in the middle) and all the surrounding cells.
--   
--   Here's an example of computing the average of all neighbouring cells,
--   repeating values at the edge of the grid when indexes are out of
--   bounds (using <a>clampWindow</a>)
--   
--   <pre>
--   gaussian :: (Dimensions dims) =&gt; Grid dims Double -&gt; Grid dims Double
--   gaussian = autoConvolute clampWindow avg
--    where
--     avg :: Grid '[3, 3] Double -&gt; Double
--     avg g = sum g / fromIntegral (length g)
--   </pre>
autoConvolute :: forall window dims f a b. (Dimensions dims, Dimensions window, Functor f, Neighboring window) => (Grid window (Coord dims) -> f (Coord dims)) -> (f a -> b) -> Grid dims a -> Grid dims b

-- | This is a fully generic version of <a>autoConvolute</a> which allows
--   the user to provide a function which builds a context from the current
--   coord, then provides a collapsing function over the same functor.
convolute :: forall dims f a b. (Functor f, Dimensions dims) => (Coord dims -> f (Coord dims)) -> (f a -> b) -> Grid dims a -> Grid dims b

-- | Use with <a>autoConvolute</a>; Clamp out-of-bounds coordinates to the
--   nearest in-bounds coord.
clampWindow :: Dimensions dims => Grid window (Coord dims) -> Grid window (Coord dims)

-- | Use with <a>autoConvolute</a>; Wrap out-of-bounds coordinates pac-man
--   style to the other side of the grid
wrapWindow :: Dimensions dims => Grid window (Coord dims) -> Grid window (Coord dims)

-- | Use with <a>autoConvolute</a>; Out of bounds coords become
--   <a>Nothing</a>
safeWindow :: Dimensions dims => Grid window (Coord dims) -> Compose (Grid window) Maybe (Coord dims)

-- | Transpose a 2 dimensional matrix. Equivalent to:
--   
--   <pre>
--   permute @[1, 0]
--   </pre>
transpose :: (KnownNat x, KnownNat y) => Grid '[x, y] a -> Grid '[y, x] a

-- | Permute dimensions of a <a>Grid</a>. This is similar to MatLab's
--   permute function
--   
--   <a>permute</a> requires a type application containing a permutation
--   pattern; The pattern is a re-ordering of the list <tt>[0..n]</tt>
--   which represents the new dimension order. For example the permutation
--   pattern <tt>[1, 2, 0]</tt> when applied to the dimensions <tt>[4, 5,
--   6]</tt> results in the dimensions <tt>[5, 6, 4]</tt>.
--   
--   For 2 dimensional matrixes, a permutation using <tt>[1, 0]</tt> is
--   simply a matrix <a>transpose</a>
--   
--   <pre>
--   λ&gt; small
--   fromNestedLists
--     [[0,1,2]
--     ,[3,4,5]
--     ,[6,7,8]]
--   
--   λ&gt; permute @[1, 0] small
--   fromNestedLists
--     [[0,3,6]
--     ,[1,4,7]
--     ,[2,5,8]]
--   </pre>
permute :: forall (key :: [Nat]) from a invertedKey. (SingI invertedKey, invertedKey ~ InvertKey (EnumFromTo 0 (Length from - 1)) key, ValidPermutation key from, Dimensions from, Dimensions (Permuted key from)) => Grid from a -> Grid (Permuted key from) a

-- | Permute the dimensions of a coordinate according to a permutation
--   pattern. see <a>permute</a> regarding permutation patterns
permuteCoord :: forall (key :: [Nat]) to from. SingI key => Coord from -> Coord to

-- | The inverse of <a>splitGrid</a>, joinGrid will nest a grid from: &gt;
--   Grid outer (Grid inner a) -&gt; Grid (outer ++ inner) a
--   
--   For example, you can nest a simple 3x3 from smaller [3] grids as
--   follows:
--   
--   <pre>
--   joinGrid (myGrid :: Grid [3] (Grid [3] a)) :: Grid '[3, 3] a
--   </pre>
joinGrid :: Grid dims (Grid ns a) -> Grid (dims ++ ns) a

-- | The inverse of <a>joinGrid</a>, splitGrid <tt>outerDims </tt>innerDims
--   will un-nest a grid from: &gt; Grid (outer ++ inner) a -&gt; Grid
--   outer (Grid inner a)
--   
--   For example, you can unnest a simple 3x3 as follows:
--   
--   <pre>
--   splitGrid @'[3] @'[3] myGrid :: Grid '[3] (Grid [3] a)
--   </pre>
splitGrid :: forall outer inner a from. (from ~ (outer ++ inner), Dimensions from, Dimensions inner, Dimensions outer, NestedLists from a ~ NestedLists outer (NestedLists inner a)) => Grid from a -> Grid outer (Grid inner a)

-- | Get the total size of a <tt>Grid</tt> of the given dimensions
--   
--   <pre>
--   gridSize @'[2, 2] == 4
--   </pre>
gridSize :: forall (dims :: [Nat]). SingI dims => Int

-- | Represents valid dimensionalities. All non empty lists of Nats have an
--   instance
class (AllC KnownNat dims, SingI dims, Enum (Coord dims), Bounded (Coord dims)) => Dimensions (dims :: [Nat])

-- | Computes the level of nesting requried to represent a given grid
--   dimensionality as a nested list
--   
--   <pre>
--   NestedLists [2, 3] Int == [[Int]]
--   NestedLists [2, 3, 4] Int == [[[Int]]]
--   </pre>
type family NestedLists (dims :: [Nat]) a
class Neighboring dims
type ValidPermutation key from = (Sort key == EnumFromTo 0 (Length from - 1)) ?! (Text "Malformed permutation hint: " :<>: ShowType key :$$: Text "When permuting matrix of size: " :<>: ShowType from :$$: Text "Key must be a permutation of " :<>: ShowType (EnumFromTo 0 (Length from - 1)) :$$: Text "e.g. the identity permutation for 2x2 is @[0, 1]" :$$: Text "e.g. matrix transpose for 2x2 is @[1, 0]")
type family Permuted (key :: [Nat]) (from :: [Nat]) :: [Nat]

module Data.Grid.Examples.Intro
simpleGrid :: Grid '[5, 5] Int
coordGrid :: Grid '[5, 5] (Coord '[5, 5])
avg :: Foldable f => f Int -> Int
mx :: Foldable f => f Int -> Int
small :: Grid '[3, 3] Int
small' :: Grid '[5, 5] Int
med :: Grid '[3, 3, 3] Int
big :: Grid '[5, 5, 5, 5] Int
gauss :: Dimensions dims => Grid dims Double -> Grid dims Double
clampGauss :: Dimensions dims => Grid dims Double -> Grid dims Double
seeNeighboring :: Grid '[3, 3] a -> Grid '[3, 3] (Grid '[3, 3] (Maybe a))
coords :: Grid '[3, 3] (Coord '[3, 3])
doubleGrid :: Grid '[3, 3] Double
simpleGauss :: Grid '[3, 3] Double
pacmanGauss :: Dimensions dims => Grid dims Double -> Grid dims Double

module Data.Grid.Examples.Conway
rule :: Grid '[3, 3] Bool -> Bool
step :: Dimensions dims => Grid dims Bool -> Grid dims Bool
glider :: [Coord '[10, 10]]
start :: Grid '[10, 10] Bool
simulate :: Int -> Grid '[10, 10] Bool
showBool :: Bool -> Char
showGrid :: Dimensions '[x, y] => Grid '[x, y] Bool -> String