Data.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
(Grid [[0,1,2],
       [3,4,5]])

Constructors

Grid (Vector a)

Instances

Functor (Grid dims)

Defined in Data.Grid

Methods

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

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

Dimensions dims => Applicative (Grid dims)

Defined in Data.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

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

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)

Dimensions dims => Distributive (Grid dims)

Defined in Data.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)

Dimensions dims => Representable (Grid dims)

Defined in Data.Grid

Associated Types

type Rep (Grid dims) :: *

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

Methods

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

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

(Dimensions dims, Show (NestedLists dims a)) => Show (Grid dims a)

Defined in Data.Grid

Methods

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

show :: Grid dims a -> String

showList :: [Grid dims a] -> ShowS

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

Defined in Data.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

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

Defined in Data.Grid

Methods

mempty :: Grid dims a

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

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

type Rep (Grid dims)

Defined in Data.Grid

type Rep (Grid dims) = Coord dims

type family GridSize (dims :: [Nat]) :: Nat where ...

Calculate the number of elements in a grid of the given dimensionality

Equations

GridSize '[] = 0

GridSize (x ': '[]) = x

GridSize (x ': xs) = x * GridSize xs

class (AllC KnownNat dims, KnownNat (GridSize dims)) => Dimensions (dims :: [Nat]) where

Represents valid dimensionalities. All non empty lists of Nats have instances

Minimal complete definition

toCoord, fromCoord, nestLists, unNestLists

Methods

toCoord :: Proxy dims -> Finite (GridSize dims) -> Coord dims

fromCoord :: Proxy dims -> Coord dims -> Finite (GridSize dims)

gridSize :: Proxy dims -> Int

nestLists :: Proxy dims -> Vector a -> NestedLists dims a

unNestLists :: Proxy dims -> NestedLists dims a -> [a]

Instances

(KnownNat (GridSize (x ': (y ': xs))), KnownNat x, Dimensions (y ': xs)) => Dimensions (x ': (y ': xs))

Defined in Data.Grid

Methods

toCoord :: Proxy (x ': (y ': xs)) -> Finite (GridSize (x ': (y ': xs))) -> Coord (x ': (y ': xs))

fromCoord :: Proxy (x ': (y ': xs)) -> Coord (x ': (y ': xs)) -> Finite (GridSize (x ': (y ': xs)))

gridSize :: Proxy (x ': (y ': xs)) -> Int

nestLists :: Proxy (x ': (y ': xs)) -> Vector a -> NestedLists (x ': (y ': xs)) a

unNestLists :: Proxy (x ': (y ': xs)) -> NestedLists (x ': (y ': xs)) a -> [a]

KnownNat x => Dimensions (x ': ([] :: [Nat]))

Defined in Data.Grid

Methods

toCoord :: Proxy (x ': []) -> Finite (GridSize (x ': [])) -> Coord (x ': [])

fromCoord :: Proxy (x ': []) -> Coord (x ': []) -> Finite (GridSize (x ': []))

gridSize :: Proxy (x ': []) -> Int

nestLists :: Proxy (x ': []) -> Vector a -> NestedLists (x ': []) a

unNestLists :: Proxy (x ': []) -> NestedLists (x ': []) a -> [a]

type family Coord (dims :: [Nat]) where ...

The coordinate type for a given dimensionality

Coord [2, 3] == Finite 2 :# Finite 3
Coord [4, 3, 2] == Finite 4 :# Finite 3 :# Finite 2

Equations

Coord '[n] = Finite n

Coord (n ': xs) = Finite n :# Coord xs

data x :# y infixr 9

Used for constructing arbitrary depth coordinate lists e.g. (Finite 2 :# Finite 3)

Constructors

x :# y infixr 9

Instances

(Eq x, Eq y) => Eq (x :# y)

Defined in Data.Grid

Methods

(==) :: (x :# y) -> (x :# y) -> Bool

(/=) :: (x :# y) -> (x :# y) -> Bool

(Ord x, Ord y) => Ord (x :# y)

Defined in Data.Grid

Methods

compare :: (x :# y) -> (x :# y) -> Ordering

(<) :: (x :# y) -> (x :# y) -> Bool

(<=) :: (x :# y) -> (x :# y) -> Bool

(>) :: (x :# y) -> (x :# y) -> Bool

(>=) :: (x :# y) -> (x :# y) -> Bool

max :: (x :# y) -> (x :# y) -> x :# y

min :: (x :# y) -> (x :# y) -> x :# y

(Show x, Show y) => Show (x :# y)

Defined in Data.Grid

Methods

showsPrec :: Int -> (x :# y) -> ShowS

show :: (x :# y) -> String

showList :: [x :# y] -> ShowS

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. Dimensions dims => (Int -> a) -> Grid dims a

Build a grid by selecting an element for each element

toNestedLists :: forall dims a. Dimensions 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. Dimensions 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

fromList :: forall a dims. (KnownNat (GridSize dims), Dimensions 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

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

Update elements of a grid