sized-grid-0.2.0.1: Multidimensional grids with sized specified at compile time

SizedGrid

Contents

Synopsis

# Rexported for generics-sop

class (AllF c xs, SListI xs) => All (c :: k -> Constraint) (xs :: [k]) #

Require a constraint for every element of a list.

If you have a datatype that is indexed over a type-level list, then you can use All to indicate that all elements of that type-level list must satisfy a given constraint.

Example: The constraint

All Eq '[ Int, Bool, Char ]

is equivalent to the constraint

(Eq Int, Eq Bool, Eq Char)

Example: A type signature such as

f :: All Eq xs => NP I xs -> ...

means that f can assume that all elements of the n-ary product satisfy Eq.

Note on superclasses: ghc cannot deduce superclasses from All constraints. You might expect the following to compile

class (Eq a) => MyClass a

foo :: (All Eq xs) => NP f xs -> z
foo = [..]

bar :: (All MyClass xs) => NP f xs -> x
bar = foo

but it will fail with an error saying that it was unable to deduce the class constraint AllF Eq xs (or similar) in the definition of bar. In cases like this you can use Dict from Data.SOP.Dict to prove conversions between constraints. See this answer on SO for more details.

Minimal complete definition

cpara_SList

Instances
 All (c :: k -> Constraint) ([] :: [k]) Instance detailsDefined in Data.SOP.Constraint Methodscpara_SList :: proxy c -> r [] -> (forall (y :: k0) (ys :: [k0]). (c y, All c ys) => r ys -> r (y ': ys)) -> r [] # (c x, All c xs) => All (c :: a -> Constraint) (x ': xs :: [a]) Instance detailsDefined in Data.SOP.Constraint Methodscpara_SList :: proxy c -> r [] -> (forall (y :: k) (ys :: [k]). (c y, All c ys) => r ys -> r (y ': ys)) -> r (x ': xs) #

type SListI = All (Top :: k -> Constraint) #

Implicit singleton list.

A singleton list can be used to reveal the structure of a type-level list argument that the function is quantified over.

Since 0.4.0.0, this is now defined in terms of All. A singleton list provides a witness for a type-level list where the elements need not satisfy any additional constraints.

Since: sop-core-0.4.0.0

class f (g x) => Compose (f :: k -> Constraint) (g :: k1 -> k) (x :: k1) infixr 9 #

Composition of constraints.

Note that the result of the composition must be a constraint, and therefore, in Compose f g, the kind of f is k -> Constraint. The kind of g, however, is l -> k and can thus be a normal type constructor.

A typical use case is in connection with All on an NP or an NS. For example, in order to denote that all elements on an NP f xs satisfy Show, we can say All (Compose Show f) xs.

Since: sop-core-0.2

Instances
 f (g x) => Compose (f :: k2 -> Constraint) (g :: k1 -> k2) (x :: k1) Instance detailsDefined in Data.SOP.Constraint

newtype I a #

The identity type functor.

Like Identity, but with a shorter name.

Constructors

 I a
Instances