Polysemy.MTL

Types

type family CanonicalEffect (p :: (Type -> Type) -> Constraint) :: (Type -> Type) -> Type -> Type

Open type-family mapping a single constraint of the form (Type -> Type) -> Constraint, e.g., MonadState s, to a polysemy effect which can be used to re-interpret that constraint, e.g., 'State s'.

Instances

type CanonicalEffect (MonadWriter w)

Defined in Polysemy.MTL

type CanonicalEffect (MonadWriter w) = Writer w

type CanonicalEffect (MonadState s)

Defined in Polysemy.MTL

type CanonicalEffect (MonadState s) = (State s :: (Type -> Type) -> Type -> Type)

type CanonicalEffect (MonadReader env)

Defined in Polysemy.MTL

type CanonicalEffect (MonadReader env) = Reader env

type CanonicalEffect (MonadError e)

Defined in Polysemy.MTL

type CanonicalEffect (MonadError e) = (Error e :: (Type -> Type) -> Type -> Type)

newtype ConstrainedAction (p :: (Type -> Type) -> Constraint) (m :: Type -> Type) (s :: Type) (x :: Type)

A newtype wrapper for a monadic action, parameterized by a constraint, p on a (Type -> Type) (e.g., a monad); m, a specific (Type -> Type); and a polysemy effect type-list r. With Data.Reflection we can create instances of p (ConstrainedAction p m r) using functions from Sem r.

Constructors

ConstrainedAction

Fields

• action :: m x

Instances

(Monad m, Monoid w, Reifies s' (Dict1 (MonadWriter w) m)) => MonadWriter w (ConstrainedAction (MonadWriter w) m s')

Defined in Polysemy.MTL

Methods

writer :: (a, w) -> ConstrainedAction (MonadWriter w) m s' a

tell :: w -> ConstrainedAction (MonadWriter w) m s' ()

listen :: ConstrainedAction (MonadWriter w) m s' a -> ConstrainedAction (MonadWriter w) m s' (a, w)

pass :: ConstrainedAction (MonadWriter w) m s' (a, w -> w) -> ConstrainedAction (MonadWriter w) m s' a

(Monad m, Reifies s' (Dict1 (MonadState s) m)) => MonadState s (ConstrainedAction (MonadState s) m s')

Defined in Polysemy.MTL

Methods

get :: ConstrainedAction (MonadState s) m s' s

put :: s -> ConstrainedAction (MonadState s) m s' ()

state :: (s -> (a, s)) -> ConstrainedAction (MonadState s) m s' a

(Monad m, Reifies s' (Dict1 (MonadReader i) m)) => MonadReader i (ConstrainedAction (MonadReader i) m s')

Defined in Polysemy.MTL

Methods

ask :: ConstrainedAction (MonadReader i) m s' i

local :: (i -> i) -> ConstrainedAction (MonadReader i) m s' a -> ConstrainedAction (MonadReader i) m s' a

reader :: (i -> a) -> ConstrainedAction (MonadReader i) m s' a

(Monad m, Reifies s' (Dict1 (MonadError e) m)) => MonadError e (ConstrainedAction (MonadError e) m s')

Defined in Polysemy.MTL

Methods

throwError :: e -> ConstrainedAction (MonadError e) m s' a

catchError :: ConstrainedAction (MonadError e) m s' a -> (e -> ConstrainedAction (MonadError e) m s' a) -> ConstrainedAction (MonadError e) m s' a

Monad m => Monad (ConstrainedAction p m s)

Defined in Polysemy.MTL

Methods

(>>=) :: ConstrainedAction p m s a -> (a -> ConstrainedAction p m s b) -> ConstrainedAction p m s b

(>>) :: ConstrainedAction p m s a -> ConstrainedAction p m s b -> ConstrainedAction p m s b

return :: a -> ConstrainedAction p m s a

fail :: String -> ConstrainedAction p m s a

Functor m => Functor (ConstrainedAction p m s)

Defined in Polysemy.MTL

Methods

fmap :: (a -> b) -> ConstrainedAction p m s a -> ConstrainedAction p m s b

(<$) :: a -> ConstrainedAction p m s b -> ConstrainedAction p m s a

Applicative m => Applicative (ConstrainedAction p m s)

Defined in Polysemy.MTL

Methods

pure :: a -> ConstrainedAction p m s a

(<*>) :: ConstrainedAction p m s (a -> b) -> ConstrainedAction p m s a -> ConstrainedAction p m s b

liftA2 :: (a -> b -> c) -> ConstrainedAction p m s a -> ConstrainedAction p m s b -> ConstrainedAction p m s c

(*>) :: ConstrainedAction p m s a -> ConstrainedAction p m s b -> ConstrainedAction p m s b

(<*) :: ConstrainedAction p m s a -> ConstrainedAction p m s b -> ConstrainedAction p m s a

(Monad m, Reifies s' (Dict1 MonadRandom m)) => MonadRandom (ConstrainedAction MonadRandom m s')

Defined in Polysemy.RandomFu

Methods

getRandomPrim :: Prim t -> ConstrainedAction MonadRandom m s' t

getRandomWord8 :: ConstrainedAction MonadRandom m s' Word8

getRandomWord16 :: ConstrainedAction MonadRandom m s' Word16

getRandomWord32 :: ConstrainedAction MonadRandom m s' Word32

getRandomWord64 :: ConstrainedAction MonadRandom m s' Word64

getRandomDouble :: ConstrainedAction MonadRandom m s' Double

getRandomNByteInteger :: Int -> ConstrainedAction MonadRandom m s' Integer

class ReifiableConstraint1 p where

For a constraint to be "absorbable" by Sem r, there needs to be an instance of this class, containing the dictionary signatures as a record of functions and the reflected entailment of p (ConstrainedAction p m r) from the reified dictionary.

Associated Types

data Dict1 (p :: (Type -> Type) -> Constraint) (m :: Type -> Type)

Methods

reifiedInstance :: Monad m => Reifies s (Dict1 p m) :- p (ConstrainedAction p m s)

Instances

ReifiableConstraint1 MonadRandom

Defined in Polysemy.RandomFu

Associated Types

data Dict1 MonadRandom m :: Type

Methods

reifiedInstance :: Monad m => Reifies s (Dict1 MonadRandom m) :- MonadRandom (ConstrainedAction MonadRandom m s)

Monoid w => ReifiableConstraint1 (MonadWriter w)

Defined in Polysemy.MTL

Associated Types

data Dict1 (MonadWriter w) m :: Type

Methods

reifiedInstance :: Monad m => Reifies s (Dict1 (MonadWriter w) m) :- MonadWriter w (ConstrainedAction (MonadWriter w) m s)

ReifiableConstraint1 (MonadState s)

Defined in Polysemy.MTL

Associated Types

data Dict1 (MonadState s) m :: Type

Methods

reifiedInstance :: Monad m => Reifies s0 (Dict1 (MonadState s) m) :- MonadState s (ConstrainedAction (MonadState s) m s0)

ReifiableConstraint1 (MonadReader i)

Defined in Polysemy.MTL

Associated Types

data Dict1 (MonadReader i) m :: Type

Methods

reifiedInstance :: Monad m => Reifies s (Dict1 (MonadReader i) m) :- MonadReader i (ConstrainedAction (MonadReader i) m s)

ReifiableConstraint1 (MonadError e)

Defined in Polysemy.MTL

Associated Types

data Dict1 (MonadError e) m :: Type

Methods

reifiedInstance :: Monad m => Reifies s (Dict1 (MonadError e) m) :- MonadError e (ConstrainedAction (MonadError e) m s)

class ReifiableConstraint1 p => IsCanonicalEffect p r where

This class contains an instance of the dictionary for some set of effects parameterized by a polysemy effect list r. Typically, you would write this instance for any r satisfying the constraint that the "canonical" effect is a member. But you could also use it to discharge constraints which require multiple polysemy effects.

Methods

canonicalDictionary :: Dict1 p (Sem r)

Instances

Member (RandomFu :: (Type -> Type) -> Type -> Type) r => IsCanonicalEffect MonadRandom r

Defined in Polysemy.RandomFu

Methods

canonicalDictionary :: Dict1 MonadRandom (Sem r)

(Monoid w, Member (Writer w) r) => IsCanonicalEffect (MonadWriter w) r

Defined in Polysemy.MTL

Methods

canonicalDictionary :: Dict1 (MonadWriter w) (Sem r)

Member (State s :: (Type -> Type) -> Type -> Type) r => IsCanonicalEffect (MonadState s) r

Defined in Polysemy.MTL

Methods

canonicalDictionary :: Dict1 (MonadState s) (Sem r)

Member (Reader i) r => IsCanonicalEffect (MonadReader i) r

Defined in Polysemy.MTL

Methods

canonicalDictionary :: Dict1 (MonadReader i) (Sem r)

Member (Error e :: (Type -> Type) -> Type -> Type) r => IsCanonicalEffect (MonadError e) r

Defined in Polysemy.MTL

Methods

canonicalDictionary :: Dict1 (MonadError e) (Sem r)

constraint-polymorphic absorber

absorb :: forall p r a. IsCanonicalEffect p r => (p (Sem r) => Sem r a) -> Sem r a

Given a "canonical" dictionary for p using the polysemy effects in r, discharge the constraint p.

constraint-monomorphic absorbers

absorbReader :: Member (Reader i) r => (MonadReader i (Sem r) => Sem r a) -> Sem r a

absorbState :: Member (State s) r => (MonadState s (Sem r) => Sem r a) -> Sem r a

absorbWriter :: (Monoid w, Member (Writer w) r) => (MonadWriter w (Sem r) => Sem r a) -> Sem r a

absorbError :: forall e r a. Member (Error e) r => (MonadError e (Sem r) => Sem r a) -> Sem r a

Re-exports

class Reifies (s :: k) a | s -> a

Minimal complete definition

reflect

Instances

KnownNat n => Reifies (n :: Nat) Integer

Defined in Data.Reflection

Methods

reflect :: proxy n -> Integer

KnownSymbol n => Reifies (n :: Symbol) String

Defined in Data.Reflection

Methods

reflect :: proxy n -> String

Reifies Z Int

Defined in Data.Reflection

Methods

reflect :: proxy Z -> Int

Reifies n Int => Reifies (D n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (D n) -> Int

Reifies n Int => Reifies (SD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (SD n) -> Int

Reifies n Int => Reifies (PD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (PD n) -> Int

(B b0, B b1, B b2, B b3, B b4, B b5, B b6, B b7, w0 ~ W b0 b1 b2 b3, w1 ~ W b4 b5 b6 b7) => Reifies (Stable w0 w1 a :: Type) a

Defined in Data.Reflection

Methods

reflect :: proxy (Stable w0 w1 a) -> a

newtype a :- b infixr 9

This is the type of entailment.

a :- b is read as a "entails" b.

With this we can actually build a category for Constraint resolution.

e.g.

Because Eq a is a superclass of Ord a, we can show that Ord a entails Eq a.

Because instance Ord a => Ord [a] exists, we can show that Ord a entails Ord [a] as well.

This relationship is captured in the :- entailment type here.

Since p :- p and entailment composes, :- forms the arrows of a Category of constraints. However, Category only became sufficiently general to support this instance in GHC 7.8, so prior to 7.8 this instance is unavailable.

But due to the coherence of instance resolution in Haskell, this Category has some very interesting properties. Notably, in the absence of IncoherentInstances, this category is "thin", which is to say that between any two objects (constraints) there is at most one distinguishable arrow.

This means that for instance, even though there are two ways to derive Ord a :- Eq [a], the answers from these two paths _must_ by construction be equal. This is a property that Haskell offers that is pretty much unique in the space of languages with things they call "type classes".

What are the two ways?

Well, we can go from Ord a :- Eq a via the superclass relationship, and then from Eq a :- Eq [a] via the instance, or we can go from Ord a :- Ord [a] via the instance then from Ord [a] :- Eq [a] through the superclass relationship and this diagram by definition must "commute".

Diagrammatically,

                   Ord a
               ins /     \ cls
                  v       v
            Ord [a]     Eq a
               cls \     / ins
                    v   v
                   Eq [a]

This safety net ensures that pretty much anything you can write with this library is sensible and can't break any assumptions on the behalf of library authors.

Constructors

Sub (a -> Dict b)

Instances

Category (:-)

Possible since GHC 7.8, when Category was made polykinded.

Defined in Data.Constraint

Methods

id :: a :- a

(.) :: (b :- c) -> (a :- b) -> a :- c

() :=> (Eq (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Eq (a :- b)

() :=> (Ord (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Ord (a :- b)

() :=> (Show (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Show (a :- b)

Eq (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

Methods

(==) :: (a :- b) -> (a :- b) -> Bool

(/=) :: (a :- b) -> (a :- b) -> Bool

(Typeable p, Typeable q, p, q) => Data (p :- q)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> (p :- q) -> c (p :- q)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (p :- q)

toConstr :: (p :- q) -> Constr

dataTypeOf :: (p :- q) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (p :- q))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (p :- q))

gmapT :: (forall b. Data b => b -> b) -> (p :- q) -> p :- q

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQ :: (forall d. Data d => d -> u) -> (p :- q) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (p :- q) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

Ord (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

Methods

compare :: (a :- b) -> (a :- b) -> Ordering

(<) :: (a :- b) -> (a :- b) -> Bool

(<=) :: (a :- b) -> (a :- b) -> Bool

(>) :: (a :- b) -> (a :- b) -> Bool

(>=) :: (a :- b) -> (a :- b) -> Bool

max :: (a :- b) -> (a :- b) -> a :- b

min :: (a :- b) -> (a :- b) -> a :- b

Show (a :- b)

Defined in Data.Constraint

Methods

showsPrec :: Int -> (a :- b) -> ShowS

show :: (a :- b) -> String

showList :: [a :- b] -> ShowS

a => NFData (a :- b)

Defined in Data.Constraint

Methods

rnf :: (a :- b) -> ()

data Dict a where

Values of type Dict p capture a dictionary for a constraint of type p.

e.g.

Dict :: Dict (Eq Int)

captures a dictionary that proves we have an:

instance Eq 'Int

Pattern matching on the Dict constructor will bring this instance into scope.

Constructors

Dict :: forall a. a => Dict a

Instances

a :=> (Read (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a)

a :=> (Monoid (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a)

a :=> (Enum (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a)

a :=> (Bounded (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a)

() :=> (Eq (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Eq (Dict a)

() :=> (Ord (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Ord (Dict a)

() :=> (Show (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Show (Dict a)

() :=> (Semigroup (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Semigroup (Dict a)

a => Bounded (Dict a)

Defined in Data.Constraint

Methods

minBound :: Dict a

maxBound :: Dict a

a => Enum (Dict a)

Defined in Data.Constraint

Methods

succ :: Dict a -> Dict a

pred :: Dict a -> Dict a

toEnum :: Int -> Dict a

fromEnum :: Dict a -> Int

enumFrom :: Dict a -> [Dict a]

enumFromThen :: Dict a -> Dict a -> [Dict a]

enumFromTo :: Dict a -> Dict a -> [Dict a]

enumFromThenTo :: Dict a -> Dict a -> Dict a -> [Dict a]

Eq (Dict a)

Defined in Data.Constraint

Methods

(==) :: Dict a -> Dict a -> Bool

(/=) :: Dict a -> Dict a -> Bool

(Typeable p, p) => Data (Dict p)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dict p -> c (Dict p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dict p)

toConstr :: Dict p -> Constr

dataTypeOf :: Dict p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dict p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dict p))

gmapT :: (forall b. Data b => b -> b) -> Dict p -> Dict p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQ :: (forall d. Data d => d -> u) -> Dict p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dict p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

Ord (Dict a)

Defined in Data.Constraint

Methods

compare :: Dict a -> Dict a -> Ordering

(<) :: Dict a -> Dict a -> Bool

(<=) :: Dict a -> Dict a -> Bool

(>) :: Dict a -> Dict a -> Bool

(>=) :: Dict a -> Dict a -> Bool

max :: Dict a -> Dict a -> Dict a

min :: Dict a -> Dict a -> Dict a

a => Read (Dict a)

Defined in Data.Constraint

Methods

readsPrec :: Int -> ReadS (Dict a)

readList :: ReadS [Dict a]

readPrec :: ReadPrec (Dict a)

readListPrec :: ReadPrec [Dict a]

Show (Dict a)

Defined in Data.Constraint

Methods

showsPrec :: Int -> Dict a -> ShowS

show :: Dict a -> String

showList :: [Dict a] -> ShowS

Semigroup (Dict a)

Defined in Data.Constraint

Methods

(<>) :: Dict a -> Dict a -> Dict a

sconcat :: NonEmpty (Dict a) -> Dict a

stimes :: Integral b => b -> Dict a -> Dict a

a => Monoid (Dict a)

Defined in Data.Constraint

Methods

mempty :: Dict a

mappend :: Dict a -> Dict a -> Dict a

mconcat :: [Dict a] -> Dict a

NFData (Dict c)

Defined in Data.Constraint

Methods

rnf :: Dict c -> ()

reflect :: Reifies s a => proxy s -> a

Recover a value inside a reify context, given a proxy for its reified type.

data Proxy (t :: k) :: forall k. k -> Type

Proxy is a type that holds no data, but has a phantom parameter of arbitrary type (or even kind). Its use is to provide type information, even though there is no value available of that type (or it may be too costly to create one).

Historically, Proxy :: Proxy a is a safer alternative to the 'undefined :: a' idiom.

>>> Proxy :: Proxy (Void, Int -> Int)
Proxy

Proxy can even hold types of higher kinds,

>>> Proxy :: Proxy Either
Proxy

>>> Proxy :: Proxy Functor
Proxy

>>> Proxy :: Proxy complicatedStructure
Proxy

Constructors

Proxy

Instances

Generic1 (Proxy :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 Proxy :: k -> Type

Methods

from1 :: Proxy a -> Rep1 Proxy a

to1 :: Rep1 Proxy a -> Proxy a

Monad (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b

(>>) :: Proxy a -> Proxy b -> Proxy b

return :: a -> Proxy a

fail :: String -> Proxy a

Functor (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

fmap :: (a -> b) -> Proxy a -> Proxy b

(<$) :: a -> Proxy b -> Proxy a

Applicative (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

pure :: a -> Proxy a

(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b

liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(*>) :: Proxy a -> Proxy b -> Proxy b

(<*) :: Proxy a -> Proxy b -> Proxy a

Foldable (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Proxy m -> m

foldMap :: Monoid m => (a -> m) -> Proxy a -> m

foldr :: (a -> b -> b) -> b -> Proxy a -> b

foldr' :: (a -> b -> b) -> b -> Proxy a -> b

foldl :: (b -> a -> b) -> b -> Proxy a -> b

foldl' :: (b -> a -> b) -> b -> Proxy a -> b

foldr1 :: (a -> a -> a) -> Proxy a -> a

foldl1 :: (a -> a -> a) -> Proxy a -> a

toList :: Proxy a -> [a]

null :: Proxy a -> Bool

length :: Proxy a -> Int

elem :: Eq a => a -> Proxy a -> Bool

maximum :: Ord a => Proxy a -> a

minimum :: Ord a => Proxy a -> a

sum :: Num a => Proxy a -> a

product :: Num a => Proxy a -> a

Traversable (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b)

sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a)

mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b)

sequence :: Monad m => Proxy (m a) -> m (Proxy a)

MonadPlus (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

mzero :: Proxy a

mplus :: Proxy a -> Proxy a -> Proxy a

Alternative (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

empty :: Proxy a

(<|>) :: Proxy a -> Proxy a -> Proxy a

some :: Proxy a -> Proxy [a]

many :: Proxy a -> Proxy [a]

Bounded (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

minBound :: Proxy t

maxBound :: Proxy t

Enum (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

succ :: Proxy s -> Proxy s

pred :: Proxy s -> Proxy s

toEnum :: Int -> Proxy s

fromEnum :: Proxy s -> Int

enumFrom :: Proxy s -> [Proxy s]

enumFromThen :: Proxy s -> Proxy s -> [Proxy s]

enumFromTo :: Proxy s -> Proxy s -> [Proxy s]

enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s]

Eq (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(==) :: Proxy s -> Proxy s -> Bool

(/=) :: Proxy s -> Proxy s -> Bool

Ord (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

compare :: Proxy s -> Proxy s -> Ordering

(<) :: Proxy s -> Proxy s -> Bool

(<=) :: Proxy s -> Proxy s -> Bool

(>) :: Proxy s -> Proxy s -> Bool

(>=) :: Proxy s -> Proxy s -> Bool

max :: Proxy s -> Proxy s -> Proxy s

min :: Proxy s -> Proxy s -> Proxy s

Read (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

readsPrec :: Int -> ReadS (Proxy t)

readList :: ReadS [Proxy t]

readPrec :: ReadPrec (Proxy t)

readListPrec :: ReadPrec [Proxy t]

Show (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

showsPrec :: Int -> Proxy s -> ShowS

show :: Proxy s -> String

showList :: [Proxy s] -> ShowS

Ix (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

range :: (Proxy s, Proxy s) -> [Proxy s]

index :: (Proxy s, Proxy s) -> Proxy s -> Int

unsafeIndex :: (Proxy s, Proxy s) -> Proxy s -> Int

inRange :: (Proxy s, Proxy s) -> Proxy s -> Bool

rangeSize :: (Proxy s, Proxy s) -> Int

unsafeRangeSize :: (Proxy s, Proxy s) -> Int

Generic (Proxy t)

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Semigroup (Proxy s)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

(<>) :: Proxy s -> Proxy s -> Proxy s

sconcat :: NonEmpty (Proxy s) -> Proxy s

stimes :: Integral b => b -> Proxy s -> Proxy s

Monoid (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

mempty :: Proxy s

mappend :: Proxy s -> Proxy s -> Proxy s

mconcat :: [Proxy s] -> Proxy s

type Rep1 (Proxy :: k -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep1 (Proxy :: k -> Type) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) (U1 :: k -> Type))

type Rep (Proxy t)

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep (Proxy t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) (U1 :: Type -> Type))