Data.Grid.Internal.Grid

Documentation

newtype Grid (dims :: [Nat]) a

An grid of arbitrary dimensions.

e.g. a Grid [2, 3] Int might look like:

generate id :: Grid [2, 3] Int
fromNestedLists [[0,1,2],
                 [3,4,5]]

Constructors

Grid

Fields

• toVector :: Vector a

Instances

Functor (Grid dims)

Defined in Data.Grid.Internal.Grid

Methods

fmap :: (a -> b) -> Grid dims a -> Grid dims b

(<$) :: a -> Grid dims b -> Grid dims a

IsGrid dims => Applicative (Grid dims)

Defined in Data.Grid.Internal.Grid

Methods

pure :: a -> Grid dims a

(<*>) :: Grid dims (a -> b) -> Grid dims a -> Grid dims b

liftA2 :: (a -> b -> c) -> Grid dims a -> Grid dims b -> Grid dims c

(*>) :: Grid dims a -> Grid dims b -> Grid dims b

(<*) :: Grid dims a -> Grid dims b -> Grid dims a

Foldable (Grid dims)

Defined in Data.Grid.Internal.Grid

Methods

fold :: Monoid m => Grid dims m -> m

foldMap :: Monoid m => (a -> m) -> Grid dims a -> m

foldr :: (a -> b -> b) -> b -> Grid dims a -> b

foldr' :: (a -> b -> b) -> b -> Grid dims a -> b

foldl :: (b -> a -> b) -> b -> Grid dims a -> b

foldl' :: (b -> a -> b) -> b -> Grid dims a -> b

foldr1 :: (a -> a -> a) -> Grid dims a -> a

foldl1 :: (a -> a -> a) -> Grid dims a -> a

toList :: Grid dims a -> [a]

null :: Grid dims a -> Bool

length :: Grid dims a -> Int

elem :: Eq a => a -> Grid dims a -> Bool

maximum :: Ord a => Grid dims a -> a

minimum :: Ord a => Grid dims a -> a

sum :: Num a => Grid dims a -> a

product :: Num a => Grid dims a -> a

Traversable (Grid dims)

Defined in Data.Grid.Internal.Grid

Methods

traverse :: Applicative f => (a -> f b) -> Grid dims a -> f (Grid dims b)

sequenceA :: Applicative f => Grid dims (f a) -> f (Grid dims a)

mapM :: Monad m => (a -> m b) -> Grid dims a -> m (Grid dims b)

sequence :: Monad m => Grid dims (m a) -> m (Grid dims a)

IsGrid dims => Distributive (Grid dims)

Defined in Data.Grid.Internal.Grid

Methods

distribute :: Functor f => f (Grid dims a) -> Grid dims (f a)

collect :: Functor f => (a -> Grid dims b) -> f a -> Grid dims (f b)

distributeM :: Monad m => m (Grid dims a) -> Grid dims (m a)

collectM :: Monad m => (a -> Grid dims b) -> m a -> Grid dims (m b)

IsGrid dims => Representable (Grid dims)

Defined in Data.Grid.Internal.Grid

Associated Types

type Rep (Grid dims) :: Type

Methods

tabulate :: (Rep (Grid dims) -> a) -> Grid dims a

index :: Grid dims a -> Rep (Grid dims) -> a

Eq a => Eq (Grid dims a)

Defined in Data.Grid.Internal.Grid

Methods

(==) :: Grid dims a -> Grid dims a -> Bool

(/=) :: Grid dims a -> Grid dims a -> Bool

(Num n, IsGrid dims) => Num (Grid dims n)

Defined in Data.Grid.Internal.Grid

Methods

(+) :: Grid dims n -> Grid dims n -> Grid dims n

(-) :: Grid dims n -> Grid dims n -> Grid dims n

(*) :: Grid dims n -> Grid dims n -> Grid dims n

negate :: Grid dims n -> Grid dims n

abs :: Grid dims n -> Grid dims n

signum :: Grid dims n -> Grid dims n

fromInteger :: Integer -> Grid dims n

(PrettyList (NestedLists dims a), IsGrid dims, Show (NestedLists dims a)) => Show (Grid dims a)

Defined in Data.Grid.Internal.Grid

Methods

showsPrec :: Int -> Grid dims a -> ShowS

show :: Grid dims a -> String

showList :: [Grid dims a] -> ShowS

(IsGrid dims, Semigroup a) => Semigroup (Grid dims a)

Defined in Data.Grid.Internal.Grid

Methods

(<>) :: Grid dims a -> Grid dims a -> Grid dims a

sconcat :: NonEmpty (Grid dims a) -> Grid dims a

stimes :: Integral b => b -> Grid dims a -> Grid dims a

(IsGrid dims, Monoid a) => Monoid (Grid dims a)

Defined in Data.Grid.Internal.Grid

Methods

mempty :: Grid dims a

mappend :: Grid dims a -> Grid dims a -> Grid dims a

mconcat :: [Grid dims a] -> Grid dims a

NFData a => NFData (Grid dims a)

Defined in Data.Grid.Internal.Grid

Methods

rnf :: Grid dims a -> ()

type Rep (Grid dims)

Defined in Data.Grid.Internal.Grid

type Rep (Grid dims) = Coord dims

type IsGrid dims = (AllC KnownNat dims, SingI dims, Sizable dims, Representable (Grid dims), Enum (Coord dims), Bounded (Coord dims), Neighboring dims)

data Coord (dims :: [Nat])

The index type for Grids.

Instances

IsList (Coord dims)

Defined in Data.Grid.Internal.Coord

Associated Types

type Item (Coord dims) :: Type

Methods

fromList :: [Item (Coord dims)] -> Coord dims

fromListN :: Int -> [Item (Coord dims)] -> Coord dims

toList :: Coord dims -> [Item (Coord dims)]

(KnownNat n, Bounded (Coord ns)) => Bounded (Coord (n ': ns))

Defined in Data.Grid.Internal.Coord

Methods

minBound :: Coord (n ': ns)

maxBound :: Coord (n ': ns)

Bounded (Coord ([] :: [Nat]))

Defined in Data.Grid.Internal.Coord

Methods

minBound :: Coord []

maxBound :: Coord []

(KnownNat x, KnownNat y, Sizable (y ': rest), Bounded (Coord rest), Enum (Coord (y ': rest))) => Enum (Coord (x ': (y ': rest)))

Defined in Data.Grid.Internal.Coord

Methods

succ :: Coord (x ': (y ': rest)) -> Coord (x ': (y ': rest))

pred :: Coord (x ': (y ': rest)) -> Coord (x ': (y ': rest))

toEnum :: Int -> Coord (x ': (y ': rest))

fromEnum :: Coord (x ': (y ': rest)) -> Int

enumFrom :: Coord (x ': (y ': rest)) -> [Coord (x ': (y ': rest))]

enumFromThen :: Coord (x ': (y ': rest)) -> Coord (x ': (y ': rest)) -> [Coord (x ': (y ': rest))]

enumFromTo :: Coord (x ': (y ': rest)) -> Coord (x ': (y ': rest)) -> [Coord (x ': (y ': rest))]

enumFromThenTo :: Coord (x ': (y ': rest)) -> Coord (x ': (y ': rest)) -> Coord (x ': (y ': rest)) -> [Coord (x ': (y ': rest))]

KnownNat n => Enum (Coord (n ': ([] :: [Nat])))

Defined in Data.Grid.Internal.Coord

Methods

succ :: Coord (n ': []) -> Coord (n ': [])

pred :: Coord (n ': []) -> Coord (n ': [])

toEnum :: Int -> Coord (n ': [])

fromEnum :: Coord (n ': []) -> Int

enumFrom :: Coord (n ': []) -> [Coord (n ': [])]

enumFromThen :: Coord (n ': []) -> Coord (n ': []) -> [Coord (n ': [])]

enumFromTo :: Coord (n ': []) -> Coord (n ': []) -> [Coord (n ': [])]

enumFromThenTo :: Coord (n ': []) -> Coord (n ': []) -> Coord (n ': []) -> [Coord (n ': [])]

Eq (Coord dims)

Defined in Data.Grid.Internal.Coord

Methods

(==) :: Coord dims -> Coord dims -> Bool

(/=) :: Coord dims -> Coord dims -> Bool

Enum (Coord ns) => Num (Coord ns)

Defined in Data.Grid.Internal.Coord

Methods

(+) :: Coord ns -> Coord ns -> Coord ns

(-) :: Coord ns -> Coord ns -> Coord ns

(*) :: Coord ns -> Coord ns -> Coord ns

negate :: Coord ns -> Coord ns

abs :: Coord ns -> Coord ns

signum :: Coord ns -> Coord ns

fromInteger :: Integer -> Coord ns

Show (Coord dims)

Defined in Data.Grid.Internal.Coord

Methods

showsPrec :: Int -> Coord dims -> ShowS

show :: Coord dims -> String

showList :: [Coord dims] -> ShowS

type Item (Coord dims)

Defined in Data.Grid.Internal.Coord

type Item (Coord dims) = Int

type family NestedLists (dims :: [Nat]) a where ...

Computes the level of nesting requried to represent a given grid dimensionality as a nested list

NestedLists [2, 3] Int == [[Int]]
NestedLists [2, 3, 4] Int == [[[Int]]]

Equations

NestedLists '[] a = a

NestedLists (_ ': xs) a = [NestedLists xs a]

generate :: forall dims a. IsGrid dims => (Int -> a) -> Grid dims a

Build a grid by selecting an element for each element

toNestedLists :: forall dims a. IsGrid dims => Grid dims a -> NestedLists dims a

Turn a grid into a nested list structure. List nesting increases for each dimension

toNestedLists (G.generate id :: Grid [2, 3] Int)
[[0,1,2],[3,4,5]]

fromNestedLists :: forall dims a. IsGrid dims => NestedLists dims a -> Maybe (Grid dims a)

Turn a nested list structure into a Grid if the list is well formed. Required list nesting increases for each dimension

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

fromNestedLists' :: forall dims a. IsGrid dims => NestedLists dims a -> Grid dims a

Partial variant of fromNestedLists which errors on malformed input

fromList :: forall dims a. IsGrid dims => [a] -> Maybe (Grid dims a)

Convert a list into a Grid or fail if not provided the correct number of elements

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

fromList' :: forall dims a. IsGrid dims => [a] -> Grid dims a

Partial variant of fromList which errors on malformed input

(//) :: forall dims a. IsGrid dims => Grid dims a -> [(Coord dims, a)] -> Grid dims a

Update elements of a grid

class Neighboring dims where

Methods

neighborCoords :: Grid dims (Coord dims)

Instances

(KnownNat n, Neighboring ns) => Neighboring (n ': ns)

Defined in Data.Grid.Internal.Grid

Methods

neighborCoords :: Grid (n ': ns) (Coord (n ': ns))

IsGrid (n ': ([] :: [Nat])) => Neighboring (n ': ([] :: [Nat]))

Defined in Data.Grid.Internal.Grid

Methods

neighborCoords :: Grid (n ': []) (Coord (n ': []))

joinGrid :: Grid dims (Grid ns a) -> Grid (dims ++ ns) a

The inverse of splitGrid, joinGrid will nest a grid from: > Grid outer (Grid inner a) -> Grid (outer ++ inner) a

For example, you can nest a simple 3x3 from smaller [3] grids as follows:

joinGrid (myGrid :: Grid [3] (Grid [3] a)) :: Grid '[3, 3] a

splitGrid :: forall outer inner a from. (IsGrid from, IsGrid inner, IsGrid outer, NestedLists from a ~ NestedLists outer (NestedLists inner a)) => Grid from a -> Grid outer (Grid inner a)

The inverse of joinGrid, splitGrid outerDims innerDims will un-nest a grid from: > Grid (outer ++ inner) a -> Grid outer (Grid inner a)

For example, you can unnest a simple 3x3 as follows:

splitGrid @'[3] @'[3] myGrid :: Grid '[3] (Grid [3] a)