Copyright	(C) Koz Ross 2019-2020
License	GPL version 3.0 or later
Maintainer	koz.ross@retro-freedom.nz
Stability	Experimental
Portability	GHC only
Safe Haskell	Trustworthy
Language	Haskell2010

Data.Finitary

Contents

Enumeration functions

Description

This package provides the Finitary type class, a range of useful 'base' instances for commonly-used finitary types, and some helper functions for enumerating values of types with Finitary instances.

For your own types, there are three possible ways to define an instance of Finitary:

Via Generic

If your data type implements Generic (and is finitary), you can automatically derive your instance:

{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}

import Data.Finitary (Finitary)
import Data.Word (Word8, Word16)
import GHC.Generics (Generic)

data Foo = Bar | Baz (Word8, Word8) | Quux Word16
   deriving stock (Eq, Generic)
   deriving anyclass (Finitary)

This is the easiest method, and also the safest, as GHC will automatically determine the cardinality of Foo, as well as defining law-abiding methods. It may be somewhat slower than a 'hand-rolled' method in some cases.

By defining only Cardinality, fromFinite and toFinite

If you want a manually-defined instance, but don't wish to define every method, only fromFinite and toFinite are needed, along with Cardinality. Cardinality in particular must be defined with care, as otherwise, you may end up with inconstructable values or indexes that don't correspond to anything.

By defining everything

For maximum control, you can define all the methods. Ensure you follow all the laws!

Synopsis

class (Eq a, KnownNat (Cardinality a)) => Finitary (a :: Type) where
- type Cardinality a :: Nat
- fromFinite :: Finite (Cardinality a) -> a
- toFinite :: a -> Finite (Cardinality a)
- start :: 1 <= Cardinality a => a
- end :: 1 <= Cardinality a => a
- previous :: a -> Maybe a
- next :: a -> Maybe a
inhabitants :: forall (a :: Type). Finitary a => [a]
inhabitantsFrom :: forall (a :: Type). Finitary a => a -> NonEmpty a
inhabitantsTo :: forall (a :: Type). Finitary a => a -> NonEmpty a
inhabitantsFromTo :: forall (a :: Type). Finitary a => a -> a -> [a]

Documentation

class (Eq a, KnownNat (Cardinality a)) => Finitary (a :: Type) where Source #

Witnesses an isomorphism between a and some (KnownNat n) => Finite n. Effectively, a lawful instance of this shows that a has exactly n (non-_|_) inhabitants, and that we have a bijection with fromFinite and toFinite as each 'direction'.

For any type a with an instance of Finitary, for every non-_|_ x :: a, we have a unique index i :: Finite n. We will also refer to any such x as an inhabitant of a. We can convert inhabitants to indexes using toFinite, and also convert indexes to inhabitants with fromFinite.

Laws

The main laws state that fromFinite should be a bijection, with toFinite as its inverse, and Cardinality must be a truthful representation of the cardinality of the type. Thus:

\[\texttt{fromFinite} \circ \texttt{toFinite} = \texttt{toFinite} \circ \texttt{fromFinite} = \texttt{id}\]
\[\forall x, y :: \texttt{Finite} \; (\texttt{Cardinality} \; a) \; \texttt{fromFinite} \; x = \texttt{fromFinite} \; y \rightarrow x = y\]
\[\forall x :: \texttt{Finite} \; (\texttt{Cardinality} \; a) \; \exists y :: a \mid \texttt{fromFinite} \; x = y\]

Furthermore, fromFinite should be _order-preserving_. Namely, if a is an instance of Ord, we must have:

\[\forall i, j :: \texttt{Finite} \; (\texttt{Cardinality} \; a) \; \texttt{fromFinite} \; i \leq \texttt{fromFinite} \; j \rightarrow i \leq j \]

Lastly, if you define any of the other methods, these laws must hold:

\[ a \neq \emptyset \rightarrow \texttt{start} :: a = \texttt{fromFinite} \; \texttt{minBound} \]
\[ a \neq \emptyset \rightarrow \texttt{end} :: a = \texttt{fromFinite} \; \texttt{maxBound} \]
\[ \forall x :: a \; \texttt{end} :: a \neq x \rightarrow \texttt{next} \; x = (\texttt{fromFinite} \circ + 1 \circ \texttt{toFinite}) \; x \]
\[ \forall x :: a \; \texttt{start} :: a \neq x \rightarrow \texttt{previous} \; x = (\texttt{fromFinite} \circ - 1 \circ \texttt{toFinite}) \; x \]

Together with the fact that Finite n is well-ordered whenever KnownNat n holds, a law-abiding Finitary instance for a type a defines a constructive well-order, witnessed by toFinite and fromFinite, which agrees with the Ord instance for a, if any.

We strongly suggest that fromFinite and toFinite should have time complexity \(\Theta(1)\), or, if that's not possible, \(O(\texttt{Cardinality} \; a)\). The latter is the case for instances generated using Generics-based derivation, but not for 'basic' types; thus, these functions for your derived types will only be as slow as their 'structure', rather than their 'contents', provided the contents are of these 'basic' types.

Minimal complete definition

Nothing

Associated Types

type Cardinality a :: Nat Source #

How many (non-_|_) inhabitants a has, as a typelevel natural number.

type Cardinality a = GCardinality (Rep a)

Methods

fromFinite :: Finite (Cardinality a) -> a Source #

Converts an index into its corresponding inhabitant.

default fromFinite :: (Generic a, GFinitary (Rep a), Cardinality a ~ GCardinality (Rep a)) => Finite (Cardinality a) -> a Source #

toFinite :: a -> Finite (Cardinality a) Source #

Converts an inhabitant to its corresponding index.

default toFinite :: (Generic a, GFinitary (Rep a), Cardinality a ~ GCardinality (Rep a)) => a -> Finite (Cardinality a) Source #

start :: 1 <= Cardinality a => a Source #

The first inhabitant, by index, assuming a has any inhabitants.

end :: 1 <= Cardinality a => a Source #

The last inhabitant, by index, assuming a has any inhabitants.

previous :: a -> Maybe a Source #

previous x gives Just the inhabitant whose index precedes the index of x, or Nothing if no such index exists.

next :: a -> Maybe a Source #

next x gives Just the inhabitant whose index follows the index of x, or Nothing if no such index exists.

Instances

Instances details

Finitary Bool Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Bool :: Nat Source # Methods fromFinite :: Finite (Cardinality Bool) -> Bool Source # toFinite :: Bool -> Finite (Cardinality Bool) Source # start :: Bool Source # end :: Bool Source # previous :: Bool -> Maybe Bool Source # next :: Bool -> Maybe Bool Source #
Finitary Char Source #	`Char` has one inhabitant per Unicode code point.
Instance details Defined in Data.Finitary Associated Types type Cardinality Char :: Nat Source # Methods fromFinite :: Finite (Cardinality Char) -> Char Source # toFinite :: Char -> Finite (Cardinality Char) Source # start :: Char Source # end :: Char Source # previous :: Char -> Maybe Char Source # next :: Char -> Maybe Char Source #
Finitary Int Source #	`Int` has a finite number of inhabitants, varying by platform. This instance will determine this when the library is built.
Instance details Defined in Data.Finitary Associated Types type Cardinality Int :: Nat Source # Methods fromFinite :: Finite (Cardinality Int) -> Int Source # toFinite :: Int -> Finite (Cardinality Int) Source # start :: Int Source # end :: Int Source # previous :: Int -> Maybe Int Source # next :: Int -> Maybe Int Source #
Finitary Int8 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Int8 :: Nat Source # Methods fromFinite :: Finite (Cardinality Int8) -> Int8 Source # toFinite :: Int8 -> Finite (Cardinality Int8) Source # start :: Int8 Source # end :: Int8 Source # previous :: Int8 -> Maybe Int8 Source # next :: Int8 -> Maybe Int8 Source #
Finitary Int16 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Int16 :: Nat Source # Methods fromFinite :: Finite (Cardinality Int16) -> Int16 Source # toFinite :: Int16 -> Finite (Cardinality Int16) Source # start :: Int16 Source # end :: Int16 Source # previous :: Int16 -> Maybe Int16 Source # next :: Int16 -> Maybe Int16 Source #
Finitary Int32 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Int32 :: Nat Source # Methods fromFinite :: Finite (Cardinality Int32) -> Int32 Source # toFinite :: Int32 -> Finite (Cardinality Int32) Source # start :: Int32 Source # end :: Int32 Source # previous :: Int32 -> Maybe Int32 Source # next :: Int32 -> Maybe Int32 Source #
Finitary Int64 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Int64 :: Nat Source # Methods fromFinite :: Finite (Cardinality Int64) -> Int64 Source # toFinite :: Int64 -> Finite (Cardinality Int64) Source # start :: Int64 Source # end :: Int64 Source # previous :: Int64 -> Maybe Int64 Source # next :: Int64 -> Maybe Int64 Source #
Finitary Ordering Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Ordering :: Nat Source # Methods fromFinite :: Finite (Cardinality Ordering) -> Ordering Source # toFinite :: Ordering -> Finite (Cardinality Ordering) Source # start :: Ordering Source # end :: Ordering Source # previous :: Ordering -> Maybe Ordering Source # next :: Ordering -> Maybe Ordering Source #
Finitary Word Source #	`Word` has a finite number of inhabitants, varying by platform. This instance will determine this when the library is built.
Instance details Defined in Data.Finitary Associated Types type Cardinality Word :: Nat Source # Methods fromFinite :: Finite (Cardinality Word) -> Word Source # toFinite :: Word -> Finite (Cardinality Word) Source # start :: Word Source # end :: Word Source # previous :: Word -> Maybe Word Source # next :: Word -> Maybe Word Source #
Finitary Word8 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Word8 :: Nat Source # Methods fromFinite :: Finite (Cardinality Word8) -> Word8 Source # toFinite :: Word8 -> Finite (Cardinality Word8) Source # start :: Word8 Source # end :: Word8 Source # previous :: Word8 -> Maybe Word8 Source # next :: Word8 -> Maybe Word8 Source #
Finitary Word16 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Word16 :: Nat Source # Methods fromFinite :: Finite (Cardinality Word16) -> Word16 Source # toFinite :: Word16 -> Finite (Cardinality Word16) Source # start :: Word16 Source # end :: Word16 Source # previous :: Word16 -> Maybe Word16 Source # next :: Word16 -> Maybe Word16 Source #
Finitary Word32 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Word32 :: Nat Source # Methods fromFinite :: Finite (Cardinality Word32) -> Word32 Source # toFinite :: Word32 -> Finite (Cardinality Word32) Source # start :: Word32 Source # end :: Word32 Source # previous :: Word32 -> Maybe Word32 Source # next :: Word32 -> Maybe Word32 Source #
Finitary Word64 Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Word64 :: Nat Source # Methods fromFinite :: Finite (Cardinality Word64) -> Word64 Source # toFinite :: Word64 -> Finite (Cardinality Word64) Source # start :: Word64 Source # end :: Word64 Source # previous :: Word64 -> Maybe Word64 Source # next :: Word64 -> Maybe Word64 Source #
Finitary () Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality () :: Nat Source # Methods fromFinite :: Finite (Cardinality ()) -> () Source # toFinite :: () -> Finite (Cardinality ()) Source # start :: () Source # end :: () Source # previous :: () -> Maybe () Source # next :: () -> Maybe () Source #
Finitary Void Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Void :: Nat Source # Methods fromFinite :: Finite (Cardinality Void) -> Void Source # toFinite :: Void -> Finite (Cardinality Void) Source # start :: Void Source # end :: Void Source # previous :: Void -> Maybe Void Source # next :: Void -> Maybe Void Source #
Finitary All Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality All :: Nat Source # Methods fromFinite :: Finite (Cardinality All) -> All Source # toFinite :: All -> Finite (Cardinality All) Source # start :: All Source # end :: All Source # previous :: All -> Maybe All Source # next :: All -> Maybe All Source #
Finitary Any Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Any :: Nat Source # Methods fromFinite :: Finite (Cardinality Any) -> Any Source # toFinite :: Any -> Finite (Cardinality Any) Source # start :: Any Source # end :: Any Source # previous :: Any -> Maybe Any Source # next :: Any -> Maybe Any Source #
Finitary Bit Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Bit :: Nat Source # Methods fromFinite :: Finite (Cardinality Bit) -> Bit Source # toFinite :: Bit -> Finite (Cardinality Bit) Source # start :: Bit Source # end :: Bit Source # previous :: Bit -> Maybe Bit Source # next :: Bit -> Maybe Bit Source #
Finitary Bit Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality Bit :: Nat Source # Methods fromFinite :: Finite (Cardinality Bit) -> Bit Source # toFinite :: Bit -> Finite (Cardinality Bit) Source # start :: Bit Source # end :: Bit Source # previous :: Bit -> Maybe Bit Source # next :: Bit -> Maybe Bit Source #
Finitary a => Finitary (Maybe a) Source #	`Maybe a` introduces one additional inhabitant (namely, `Nothing`) to `a`.
Instance details Defined in Data.Finitary Associated Types type Cardinality (Maybe a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Maybe a)) -> Maybe a Source # toFinite :: Maybe a -> Finite (Cardinality (Maybe a)) Source # start :: Maybe a Source # end :: Maybe a Source # previous :: Maybe a -> Maybe (Maybe a) Source # next :: Maybe a -> Maybe (Maybe a) Source #
Finitary a => Finitary (Min a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Min a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Min a)) -> Min a Source # toFinite :: Min a -> Finite (Cardinality (Min a)) Source # start :: Min a Source # end :: Min a Source # previous :: Min a -> Maybe (Min a) Source # next :: Min a -> Maybe (Min a) Source #
Finitary a => Finitary (Max a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Max a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Max a)) -> Max a Source # toFinite :: Max a -> Finite (Cardinality (Max a)) Source # start :: Max a Source # end :: Max a Source # previous :: Max a -> Maybe (Max a) Source # next :: Max a -> Maybe (Max a) Source #
Finitary a => Finitary (First a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (First a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (First a)) -> First a Source # toFinite :: First a -> Finite (Cardinality (First a)) Source # start :: First a Source # end :: First a Source # previous :: First a -> Maybe (First a) Source # next :: First a -> Maybe (First a) Source #
Finitary a => Finitary (Last a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Last a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Last a)) -> Last a Source # toFinite :: Last a -> Finite (Cardinality (Last a)) Source # start :: Last a Source # end :: Last a Source # previous :: Last a -> Maybe (Last a) Source # next :: Last a -> Maybe (Last a) Source #
Finitary a => Finitary (Identity a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Identity a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Identity a)) -> Identity a Source # toFinite :: Identity a -> Finite (Cardinality (Identity a)) Source # start :: Identity a Source # end :: Identity a Source # previous :: Identity a -> Maybe (Identity a) Source # next :: Identity a -> Maybe (Identity a) Source #
Finitary a => Finitary (Dual a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Dual a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Dual a)) -> Dual a Source # toFinite :: Dual a -> Finite (Cardinality (Dual a)) Source # start :: Dual a Source # end :: Dual a Source # previous :: Dual a -> Maybe (Dual a) Source # next :: Dual a -> Maybe (Dual a) Source #
Finitary a => Finitary (Sum a) Source #	For any `newtype`-esque thing over a type with a `Finitary` instance, we can just 'inherit' the behaviour of `a`.
Instance details Defined in Data.Finitary Associated Types type Cardinality (Sum a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Sum a)) -> Sum a Source # toFinite :: Sum a -> Finite (Cardinality (Sum a)) Source # start :: Sum a Source # end :: Sum a Source # previous :: Sum a -> Maybe (Sum a) Source # next :: Sum a -> Maybe (Sum a) Source #
Finitary a => Finitary (Product a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Product a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Product a)) -> Product a Source # toFinite :: Product a -> Finite (Cardinality (Product a)) Source # start :: Product a Source # end :: Product a Source # previous :: Product a -> Maybe (Product a) Source # next :: Product a -> Maybe (Product a) Source #
Finitary a => Finitary (Down a) Source #	Despite the `newtype`-esque nature of `Down`, due to the requirement that `fromFinite` is order-preserving, the instance for `Down a` reverses the indexing.
Instance details Defined in Data.Finitary Associated Types type Cardinality (Down a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Down a)) -> Down a Source # toFinite :: Down a -> Finite (Cardinality (Down a)) Source # start :: Down a Source # end :: Down a Source # previous :: Down a -> Maybe (Down a) Source # next :: Down a -> Maybe (Down a) Source #
KnownNat n => Finitary (Finite n) Source #	Since any type is isomorphic to itself, it follows that a 'valid' `Finite n` (meaning that `n` is a `KnownNat`) has finite cardinality.
Instance details Defined in Data.Finitary Associated Types type Cardinality (Finite n) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Finite n)) -> Finite n Source # toFinite :: Finite n -> Finite (Cardinality (Finite n)) Source # start :: Finite n Source # end :: Finite n Source # previous :: Finite n -> Maybe (Finite n) Source # next :: Finite n -> Maybe (Finite n) Source #
(Finitary a, Finitary b) => Finitary (Either a b) Source #	The sum of two finite types will also be finite, with a cardinality equal to the sum of their cardinalities.
Instance details Defined in Data.Finitary Associated Types type Cardinality (Either a b) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Either a b)) -> Either a b Source # toFinite :: Either a b -> Finite (Cardinality (Either a b)) Source # start :: Either a b Source # end :: Either a b Source # previous :: Either a b -> Maybe (Either a b) Source # next :: Either a b -> Maybe (Either a b) Source #
(Finitary a, Finitary b) => Finitary (a, b) Source #	The product of two finite types will also be finite, with a cardinality equal to the product of their cardinalities.
Instance details Defined in Data.Finitary Associated Types type Cardinality (a, b) :: Nat Source # Methods fromFinite :: Finite (Cardinality (a, b)) -> (a, b) Source # toFinite :: (a, b) -> Finite (Cardinality (a, b)) Source # start :: (a, b) Source # end :: (a, b) Source # previous :: (a, b) -> Maybe (a, b) Source # next :: (a, b) -> Maybe (a, b) Source #
Finitary (Proxy a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Proxy a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Proxy a)) -> Proxy a Source # toFinite :: Proxy a -> Finite (Cardinality (Proxy a)) Source # start :: Proxy a Source # end :: Proxy a Source # previous :: Proxy a -> Maybe (Proxy a) Source # next :: Proxy a -> Maybe (Proxy a) Source #
(Finitary a, KnownNat n) => Finitary (Vector n a) Source #	A fixed-length vector over a type `a` with an instance of `Finitary` can be thought of as a fixed-length word over an alphabet of size `Cardinality a`. Since there are only finitely-many of these, we can index them in lex order, with the ordering determined by the `Finitary a` instance (thus, the 'first' such `Vector` is the one where each element is `start :: a`, and the 'last' is the one where each element is `end :: a`).
Instance details Defined in Data.Finitary Associated Types type Cardinality (Vector n a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Vector n a)) -> Vector n a Source # toFinite :: Vector n a -> Finite (Cardinality (Vector n a)) Source # start :: Vector n a Source # end :: Vector n a Source # previous :: Vector n a -> Maybe (Vector n a) Source # next :: Vector n a -> Maybe (Vector n a) Source #
(Finitary a, Storable a, KnownNat n) => Finitary (Vector n a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Vector n a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Vector n a)) -> Vector n a Source # toFinite :: Vector n a -> Finite (Cardinality (Vector n a)) Source # start :: Vector n a Source # end :: Vector n a Source # previous :: Vector n a -> Maybe (Vector n a) Source # next :: Vector n a -> Maybe (Vector n a) Source #
(Finitary a, Unbox a, KnownNat n) => Finitary (Vector n a) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Vector n a) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Vector n a)) -> Vector n a Source # toFinite :: Vector n a -> Finite (Cardinality (Vector n a)) Source # start :: Vector n a Source # end :: Vector n a Source # previous :: Vector n a -> Maybe (Vector n a) Source # next :: Vector n a -> Maybe (Vector n a) Source #
(Finitary a, Finitary b, Finitary c) => Finitary (a, b, c) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (a, b, c) :: Nat Source # Methods fromFinite :: Finite (Cardinality (a, b, c)) -> (a, b, c) Source # toFinite :: (a, b, c) -> Finite (Cardinality (a, b, c)) Source # start :: (a, b, c) Source # end :: (a, b, c) Source # previous :: (a, b, c) -> Maybe (a, b, c) Source # next :: (a, b, c) -> Maybe (a, b, c) Source #
Finitary a => Finitary (Const a b) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (Const a b) :: Nat Source # Methods fromFinite :: Finite (Cardinality (Const a b)) -> Const a b Source # toFinite :: Const a b -> Finite (Cardinality (Const a b)) Source # start :: Const a b Source # end :: Const a b Source # previous :: Const a b -> Maybe (Const a b) Source # next :: Const a b -> Maybe (Const a b) Source #
(Finitary a, Finitary b, Finitary c, Finitary d) => Finitary (a, b, c, d) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (a, b, c, d) :: Nat Source # Methods fromFinite :: Finite (Cardinality (a, b, c, d)) -> (a, b, c, d) Source # toFinite :: (a, b, c, d) -> Finite (Cardinality (a, b, c, d)) Source # start :: (a, b, c, d) Source # end :: (a, b, c, d) Source # previous :: (a, b, c, d) -> Maybe (a, b, c, d) Source # next :: (a, b, c, d) -> Maybe (a, b, c, d) Source #
(Finitary a, Finitary b, Finitary c, Finitary d, Finitary e) => Finitary (a, b, c, d, e) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (a, b, c, d, e) :: Nat Source # Methods fromFinite :: Finite (Cardinality (a, b, c, d, e)) -> (a, b, c, d, e) Source # toFinite :: (a, b, c, d, e) -> Finite (Cardinality (a, b, c, d, e)) Source # start :: (a, b, c, d, e) Source # end :: (a, b, c, d, e) Source # previous :: (a, b, c, d, e) -> Maybe (a, b, c, d, e) Source # next :: (a, b, c, d, e) -> Maybe (a, b, c, d, e) Source #
(Finitary a, Finitary b, Finitary c, Finitary d, Finitary e, Finitary f) => Finitary (a, b, c, d, e, f) Source #
Instance details Defined in Data.Finitary Associated Types type Cardinality (a, b, c, d, e, f) :: Nat Source # Methods fromFinite :: Finite (Cardinality (a, b, c, d, e, f)) -> (a, b, c, d, e, f) Source # toFinite :: (a, b, c, d, e, f) -> Finite (Cardinality (a, b, c, d, e, f)) Source # start :: (a, b, c, d, e, f) Source # end :: (a, b, c, d, e, f) Source # previous :: (a, b, c, d, e, f) -> Maybe (a, b, c, d, e, f) Source # next :: (a, b, c, d, e, f) -> Maybe (a, b, c, d, e, f) Source #

Enumeration functions

inhabitants :: forall (a :: Type). Finitary a => [a] Source #

Produce every inhabitant of a, in ascending order of indexes. If you want descending order, use Down a instead.

inhabitantsFrom :: forall (a :: Type). Finitary a => a -> NonEmpty a Source #

Produce every inhabitant of a, starting with the argument, in ascending order of indexes. If you want descending order, use Down a instead.

inhabitantsTo :: forall (a :: Type). Finitary a => a -> NonEmpty a Source #

Produce every inhabitant of a, up to and including the argument, in ascending order of indexes. If you want descending order, use Down a instead.

inhabitantsFromTo :: forall (a :: Type). Finitary a => a -> a -> [a] Source #

Produce every inhabitant of a, starting with the first argument, up to the second argument, in ascending order of indexes. inhabitantsFromTo x y will produce the empty list if toFinite x > toFinite y. If you want descending order, use Down a instead.